mirror of
https://github.com/rust-lang/rust-analyzer.git
synced 2025-10-03 07:04:49 +00:00
Split off path expression inference code into submodule
This commit is contained in:
Florian Diebold
parent
c2d9cca4e4
commit
4f1afe77b9
2 changed files with 199 additions and 172 deletions
|
|
@ -45,13 +45,14 @@ use crate::{
|
||||||
name,
|
name,
|
||||||
nameres::Namespace,
|
nameres::Namespace,
|
||||||
path::{known, GenericArg, GenericArgs},
|
path::{known, GenericArg, GenericArgs},
|
||||||
resolve::{ResolveValueResult, Resolver, TypeNs, ValueNs},
|
resolve::{Resolver, TypeNs},
|
||||||
ty::infer::diagnostics::InferenceDiagnostic,
|
ty::infer::diagnostics::InferenceDiagnostic,
|
||||||
type_ref::{Mutability, TypeRef},
|
type_ref::{Mutability, TypeRef},
|
||||||
Adt, AssocItem, ConstData, DefWithBody, FnData, Function, HasBody, Name, Path, StructField,
|
Adt, AssocItem, ConstData, DefWithBody, FnData, Function, HasBody, Name, Path, StructField,
|
||||||
};
|
};
|
||||||
|
|
||||||
mod unify;
|
mod unify;
|
||||||
|
mod path;
|
||||||
|
|
||||||
/// The entry point of type inference.
|
/// The entry point of type inference.
|
||||||
pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
|
pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
|
||||||
|
|
@ -466,175 +467,6 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn infer_path_expr(&mut self, resolver: &Resolver, path: &Path, id: ExprOrPatId) -> Option<Ty> {
|
|
||||||
let (value, self_subst) = if let crate::PathKind::Type(type_ref) = &path.kind {
|
|
||||||
if path.segments.is_empty() {
|
|
||||||
// This can't actually happen syntax-wise
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
let ty = self.make_ty(type_ref);
|
|
||||||
let remaining_segments_for_ty = &path.segments[..path.segments.len() - 1];
|
|
||||||
let ty = Ty::from_type_relative_path(self.db, resolver, ty, remaining_segments_for_ty);
|
|
||||||
self.resolve_ty_assoc_item(
|
|
||||||
ty,
|
|
||||||
path.segments.last().expect("path had at least one segment"),
|
|
||||||
id,
|
|
||||||
)?
|
|
||||||
} else {
|
|
||||||
let value_or_partial = resolver.resolve_path_in_value_ns(self.db, &path)?;
|
|
||||||
|
|
||||||
match value_or_partial {
|
|
||||||
ResolveValueResult::ValueNs(it) => (it, None),
|
|
||||||
ResolveValueResult::Partial(def, remaining_index) => {
|
|
||||||
self.resolve_assoc_item(def, path, remaining_index, id)?
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let typable: TypableDef = match value {
|
|
||||||
ValueNs::LocalBinding(pat) => {
|
|
||||||
let ty = self.result.type_of_pat.get(pat)?.clone();
|
|
||||||
let ty = self.resolve_ty_as_possible(&mut vec![], ty);
|
|
||||||
return Some(ty);
|
|
||||||
}
|
|
||||||
ValueNs::Function(it) => it.into(),
|
|
||||||
ValueNs::Const(it) => it.into(),
|
|
||||||
ValueNs::Static(it) => it.into(),
|
|
||||||
ValueNs::Struct(it) => it.into(),
|
|
||||||
ValueNs::EnumVariant(it) => it.into(),
|
|
||||||
};
|
|
||||||
|
|
||||||
let mut ty = self.db.type_for_def(typable, Namespace::Values);
|
|
||||||
if let Some(self_subst) = self_subst {
|
|
||||||
ty = ty.subst(&self_subst);
|
|
||||||
}
|
|
||||||
|
|
||||||
let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
|
|
||||||
let ty = ty.subst(&substs);
|
|
||||||
let ty = self.insert_type_vars(ty);
|
|
||||||
let ty = self.normalize_associated_types_in(ty);
|
|
||||||
Some(ty)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn resolve_assoc_item(
|
|
||||||
&mut self,
|
|
||||||
def: TypeNs,
|
|
||||||
path: &Path,
|
|
||||||
remaining_index: usize,
|
|
||||||
id: ExprOrPatId,
|
|
||||||
) -> Option<(ValueNs, Option<Substs>)> {
|
|
||||||
assert!(remaining_index < path.segments.len());
|
|
||||||
// there may be more intermediate segments between the resolved one and
|
|
||||||
// the end. Only the last segment needs to be resolved to a value; from
|
|
||||||
// the segments before that, we need to get either a type or a trait ref.
|
|
||||||
|
|
||||||
let resolved_segment = &path.segments[remaining_index - 1];
|
|
||||||
let remaining_segments = &path.segments[remaining_index..];
|
|
||||||
let is_before_last = remaining_segments.len() == 1;
|
|
||||||
|
|
||||||
match (def, is_before_last) {
|
|
||||||
(TypeNs::Trait(_trait), true) => {
|
|
||||||
// FIXME Associated item of trait, e.g. `Default::default`
|
|
||||||
None
|
|
||||||
}
|
|
||||||
(def, _) => {
|
|
||||||
// Either we already have a type (e.g. `Vec::new`), or we have a
|
|
||||||
// trait but it's not the last segment, so the next segment
|
|
||||||
// should resolve to an associated type of that trait (e.g. `<T
|
|
||||||
// as Iterator>::Item::default`)
|
|
||||||
let remaining_segments_for_ty = &remaining_segments[..remaining_segments.len() - 1];
|
|
||||||
let ty = Ty::from_partly_resolved_hir_path(
|
|
||||||
self.db,
|
|
||||||
&self.resolver,
|
|
||||||
def,
|
|
||||||
resolved_segment,
|
|
||||||
remaining_segments_for_ty,
|
|
||||||
);
|
|
||||||
if let Ty::Unknown = ty {
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
|
|
||||||
let segment =
|
|
||||||
remaining_segments.last().expect("there should be at least one segment here");
|
|
||||||
|
|
||||||
self.resolve_ty_assoc_item(ty, segment, id)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn resolve_ty_assoc_item(
|
|
||||||
&mut self,
|
|
||||||
ty: Ty,
|
|
||||||
segment: &crate::path::PathSegment,
|
|
||||||
id: ExprOrPatId,
|
|
||||||
) -> Option<(ValueNs, Option<Substs>)> {
|
|
||||||
if let Ty::Unknown = ty {
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
|
|
||||||
let krate = self.resolver.krate()?;
|
|
||||||
|
|
||||||
// Find impl
|
|
||||||
// FIXME: consider trait candidates
|
|
||||||
let item = ty.clone().iterate_impl_items(self.db, krate, |item| match item {
|
|
||||||
AssocItem::Function(func) => {
|
|
||||||
if segment.name == func.name(self.db) {
|
|
||||||
Some(AssocItem::Function(func))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
AssocItem::Const(konst) => {
|
|
||||||
if konst.name(self.db).map_or(false, |n| n == segment.name) {
|
|
||||||
Some(AssocItem::Const(konst))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
AssocItem::TypeAlias(_) => None,
|
|
||||||
})?;
|
|
||||||
let def = match item {
|
|
||||||
AssocItem::Function(f) => ValueNs::Function(f),
|
|
||||||
AssocItem::Const(c) => ValueNs::Const(c),
|
|
||||||
AssocItem::TypeAlias(_) => unreachable!(),
|
|
||||||
};
|
|
||||||
let substs = self.find_self_types(&def, ty);
|
|
||||||
|
|
||||||
self.write_assoc_resolution(id, item);
|
|
||||||
Some((def, substs))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn find_self_types(&self, def: &ValueNs, actual_def_ty: Ty) -> Option<Substs> {
|
|
||||||
if let ValueNs::Function(func) = def {
|
|
||||||
// We only do the infer if parent has generic params
|
|
||||||
let gen = func.generic_params(self.db);
|
|
||||||
if gen.count_parent_params() == 0 {
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
|
|
||||||
let impl_block = func.impl_block(self.db)?.target_ty(self.db);
|
|
||||||
let impl_block_substs = impl_block.substs()?;
|
|
||||||
let actual_substs = actual_def_ty.substs()?;
|
|
||||||
|
|
||||||
let mut new_substs = vec![Ty::Unknown; gen.count_parent_params()];
|
|
||||||
|
|
||||||
// The following code *link up* the function actual parma type
|
|
||||||
// and impl_block type param index
|
|
||||||
impl_block_substs.iter().zip(actual_substs.iter()).for_each(|(param, pty)| {
|
|
||||||
if let Ty::Param { idx, .. } = param {
|
|
||||||
if let Some(s) = new_substs.get_mut(*idx as usize) {
|
|
||||||
*s = pty.clone();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
Some(Substs(new_substs.into()))
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantDef>) {
|
fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantDef>) {
|
||||||
let path = match path {
|
let path = match path {
|
||||||
Some(path) => path,
|
Some(path) => path,
|
||||||
|
|
@ -807,7 +639,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
|
||||||
Pat::Path(path) => {
|
Pat::Path(path) => {
|
||||||
// FIXME use correct resolver for the surrounding expression
|
// FIXME use correct resolver for the surrounding expression
|
||||||
let resolver = self.resolver.clone();
|
let resolver = self.resolver.clone();
|
||||||
self.infer_path_expr(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
|
self.infer_path(&resolver, &path, pat.into()).unwrap_or(Ty::Unknown)
|
||||||
}
|
}
|
||||||
Pat::Bind { mode, name: _, subpat } => {
|
Pat::Bind { mode, name: _, subpat } => {
|
||||||
let mode = if mode == &BindingAnnotation::Unannotated {
|
let mode = if mode == &BindingAnnotation::Unannotated {
|
||||||
|
|
@ -1121,7 +953,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
|
||||||
Expr::Path(p) => {
|
Expr::Path(p) => {
|
||||||
// FIXME this could be more efficient...
|
// FIXME this could be more efficient...
|
||||||
let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
|
let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
|
||||||
self.infer_path_expr(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
|
self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
|
||||||
}
|
}
|
||||||
Expr::Continue => Ty::simple(TypeCtor::Never),
|
Expr::Continue => Ty::simple(TypeCtor::Never),
|
||||||
Expr::Break { expr } => {
|
Expr::Break { expr } => {
|
||||||
|
|
|
||||||
195
crates/ra_hir/src/ty/infer/path.rs
Normal file
195
crates/ra_hir/src/ty/infer/path.rs
Normal file
|
|
@ -0,0 +1,195 @@
|
||||||
|
//! Path expression resolution.
|
||||||
|
|
||||||
|
use super::{ExprOrPatId, InferenceContext};
|
||||||
|
use crate::{
|
||||||
|
db::HirDatabase,
|
||||||
|
resolve::{ResolveValueResult, Resolver, TypeNs, ValueNs},
|
||||||
|
ty::{Substs, Ty, TypableDef, TypeWalk},
|
||||||
|
AssocItem, HasGenericParams, Namespace, Path,
|
||||||
|
};
|
||||||
|
|
||||||
|
impl<'a, D: HirDatabase> InferenceContext<'a, D> {
|
||||||
|
pub(super) fn infer_path(
|
||||||
|
&mut self,
|
||||||
|
resolver: &Resolver,
|
||||||
|
path: &Path,
|
||||||
|
id: ExprOrPatId,
|
||||||
|
) -> Option<Ty> {
|
||||||
|
let ty = self.resolve_value_path(resolver, path, id)?;
|
||||||
|
let ty = self.insert_type_vars(ty);
|
||||||
|
let ty = self.normalize_associated_types_in(ty);
|
||||||
|
Some(ty)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn resolve_value_path(
|
||||||
|
&mut self,
|
||||||
|
resolver: &Resolver,
|
||||||
|
path: &Path,
|
||||||
|
id: ExprOrPatId,
|
||||||
|
) -> Option<Ty> {
|
||||||
|
let (value, self_subst) = if let crate::PathKind::Type(type_ref) = &path.kind {
|
||||||
|
if path.segments.is_empty() {
|
||||||
|
// This can't actually happen syntax-wise
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let ty = self.make_ty(type_ref);
|
||||||
|
let remaining_segments_for_ty = &path.segments[..path.segments.len() - 1];
|
||||||
|
let ty = Ty::from_type_relative_path(self.db, resolver, ty, remaining_segments_for_ty);
|
||||||
|
self.resolve_ty_assoc_item(
|
||||||
|
ty,
|
||||||
|
path.segments.last().expect("path had at least one segment"),
|
||||||
|
id,
|
||||||
|
)?
|
||||||
|
} else {
|
||||||
|
let value_or_partial = resolver.resolve_path_in_value_ns(self.db, &path)?;
|
||||||
|
|
||||||
|
match value_or_partial {
|
||||||
|
ResolveValueResult::ValueNs(it) => (it, None),
|
||||||
|
ResolveValueResult::Partial(def, remaining_index) => {
|
||||||
|
self.resolve_assoc_item(def, path, remaining_index, id)?
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let typable: TypableDef = match value {
|
||||||
|
ValueNs::LocalBinding(pat) => {
|
||||||
|
let ty = self.result.type_of_pat.get(pat)?.clone();
|
||||||
|
let ty = self.resolve_ty_as_possible(&mut vec![], ty);
|
||||||
|
return Some(ty);
|
||||||
|
}
|
||||||
|
ValueNs::Function(it) => it.into(),
|
||||||
|
ValueNs::Const(it) => it.into(),
|
||||||
|
ValueNs::Static(it) => it.into(),
|
||||||
|
ValueNs::Struct(it) => it.into(),
|
||||||
|
ValueNs::EnumVariant(it) => it.into(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut ty = self.db.type_for_def(typable, Namespace::Values);
|
||||||
|
if let Some(self_subst) = self_subst {
|
||||||
|
ty = ty.subst(&self_subst);
|
||||||
|
}
|
||||||
|
|
||||||
|
let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
|
||||||
|
let ty = ty.subst(&substs);
|
||||||
|
Some(ty)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn resolve_assoc_item(
|
||||||
|
&mut self,
|
||||||
|
def: TypeNs,
|
||||||
|
path: &Path,
|
||||||
|
remaining_index: usize,
|
||||||
|
id: ExprOrPatId,
|
||||||
|
) -> Option<(ValueNs, Option<Substs>)> {
|
||||||
|
assert!(remaining_index < path.segments.len());
|
||||||
|
// there may be more intermediate segments between the resolved one and
|
||||||
|
// the end. Only the last segment needs to be resolved to a value; from
|
||||||
|
// the segments before that, we need to get either a type or a trait ref.
|
||||||
|
|
||||||
|
let resolved_segment = &path.segments[remaining_index - 1];
|
||||||
|
let remaining_segments = &path.segments[remaining_index..];
|
||||||
|
let is_before_last = remaining_segments.len() == 1;
|
||||||
|
|
||||||
|
match (def, is_before_last) {
|
||||||
|
(TypeNs::Trait(_trait), true) => {
|
||||||
|
// FIXME Associated item of trait, e.g. `Default::default`
|
||||||
|
None
|
||||||
|
}
|
||||||
|
(def, _) => {
|
||||||
|
// Either we already have a type (e.g. `Vec::new`), or we have a
|
||||||
|
// trait but it's not the last segment, so the next segment
|
||||||
|
// should resolve to an associated type of that trait (e.g. `<T
|
||||||
|
// as Iterator>::Item::default`)
|
||||||
|
let remaining_segments_for_ty = &remaining_segments[..remaining_segments.len() - 1];
|
||||||
|
let ty = Ty::from_partly_resolved_hir_path(
|
||||||
|
self.db,
|
||||||
|
&self.resolver,
|
||||||
|
def,
|
||||||
|
resolved_segment,
|
||||||
|
remaining_segments_for_ty,
|
||||||
|
);
|
||||||
|
if let Ty::Unknown = ty {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
|
||||||
|
let segment =
|
||||||
|
remaining_segments.last().expect("there should be at least one segment here");
|
||||||
|
|
||||||
|
self.resolve_ty_assoc_item(ty, segment, id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn resolve_ty_assoc_item(
|
||||||
|
&mut self,
|
||||||
|
ty: Ty,
|
||||||
|
segment: &crate::path::PathSegment,
|
||||||
|
id: ExprOrPatId,
|
||||||
|
) -> Option<(ValueNs, Option<Substs>)> {
|
||||||
|
if let Ty::Unknown = ty {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
|
||||||
|
let krate = self.resolver.krate()?;
|
||||||
|
|
||||||
|
// Find impl
|
||||||
|
// FIXME: consider trait candidates
|
||||||
|
let item = ty.clone().iterate_impl_items(self.db, krate, |item| match item {
|
||||||
|
AssocItem::Function(func) => {
|
||||||
|
if segment.name == func.name(self.db) {
|
||||||
|
Some(AssocItem::Function(func))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
AssocItem::Const(konst) => {
|
||||||
|
if konst.name(self.db).map_or(false, |n| n == segment.name) {
|
||||||
|
Some(AssocItem::Const(konst))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
AssocItem::TypeAlias(_) => None,
|
||||||
|
})?;
|
||||||
|
let def = match item {
|
||||||
|
AssocItem::Function(f) => ValueNs::Function(f),
|
||||||
|
AssocItem::Const(c) => ValueNs::Const(c),
|
||||||
|
AssocItem::TypeAlias(_) => unreachable!(),
|
||||||
|
};
|
||||||
|
let substs = self.find_self_types(&def, ty);
|
||||||
|
|
||||||
|
self.write_assoc_resolution(id, item);
|
||||||
|
Some((def, substs))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn find_self_types(&self, def: &ValueNs, actual_def_ty: Ty) -> Option<Substs> {
|
||||||
|
if let ValueNs::Function(func) = def {
|
||||||
|
// We only do the infer if parent has generic params
|
||||||
|
let gen = func.generic_params(self.db);
|
||||||
|
if gen.count_parent_params() == 0 {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
|
||||||
|
let impl_block = func.impl_block(self.db)?.target_ty(self.db);
|
||||||
|
let impl_block_substs = impl_block.substs()?;
|
||||||
|
let actual_substs = actual_def_ty.substs()?;
|
||||||
|
|
||||||
|
let mut new_substs = vec![Ty::Unknown; gen.count_parent_params()];
|
||||||
|
|
||||||
|
// The following code *link up* the function actual parma type
|
||||||
|
// and impl_block type param index
|
||||||
|
impl_block_substs.iter().zip(actual_substs.iter()).for_each(|(param, pty)| {
|
||||||
|
if let Ty::Param { idx, .. } = param {
|
||||||
|
if let Some(s) = new_substs.get_mut(*idx as usize) {
|
||||||
|
*s = pty.clone();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
Some(Substs(new_substs.into()))
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Add table
Add a link
Reference in a new issue