crates/hir_ty/src/infer/path.rs

   1 //! Path expression resolution.
   2
   3 use std::iter;
   4
   5 use chalk_ir::cast::Cast;
   6 use hir_def::{
   7     path::{Path, PathSegment},
   8     resolver::{ResolveValueResult, Resolver, TypeNs, ValueNs},
   9     AdtId, AssocContainerId, AssocItemId, EnumVariantId, Lookup,
  10 };
  11 use hir_expand::name::Name;
  12
  13 use crate::{method_resolution, Interner, Substitution, Ty, TyBuilder, TyKind, ValueTyDefId};
  14
  15 use super::{ExprOrPatId, InferenceContext, TraitRef};
  16
  17 impl<'a> InferenceContext<'a> {
  18     pub(super) fn infer_path(
  19         &mut self,
  20         resolver: &Resolver,
  21         path: &Path,
  22         id: ExprOrPatId,
  23     ) -> Option<Ty> {
  24         let ty = self.resolve_value_path(resolver, path, id)?;
  25         let ty = self.insert_type_vars(ty);
  26         let ty = self.normalize_associated_types_in(ty);
  27         Some(ty)
  28     }
  29
  30     fn resolve_value_path(
  31         &mut self,
  32         resolver: &Resolver,
  33         path: &Path,
  34         id: ExprOrPatId,
  35     ) -> Option<Ty> {
  36         let (value, self_subst) = if let Some(type_ref) = path.type_anchor() {
  37             if path.segments().is_empty() {
  38                 // This can't actually happen syntax-wise
  39                 return None;
  40             }
  41             let ty = self.make_ty(type_ref);
  42             let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1);
  43             let ctx = crate::lower::TyLoweringContext::new(self.db, &resolver);
  44             let (ty, _) = ctx.lower_ty_relative_path(ty, None, remaining_segments_for_ty);
  45             self.resolve_ty_assoc_item(
  46                 ty,
  47                 &path.segments().last().expect("path had at least one segment").name,
  48                 id,
  49             )?
  50         } else {
  51             let value_or_partial =
  52                 resolver.resolve_path_in_value_ns(self.db.upcast(), path.mod_path())?;
  53
  54             match value_or_partial {
  55                 ResolveValueResult::ValueNs(it) => (it, None),
  56                 ResolveValueResult::Partial(def, remaining_index) => {
  57                     self.resolve_assoc_item(def, path, remaining_index, id)?
  58                 }
  59             }
  60         };
  61
  62         let typable: ValueTyDefId = match value {
  63             ValueNs::LocalBinding(pat) => {
  64                 let ty = self.result.type_of_pat.get(pat)?.clone();
  65                 let ty = self.resolve_ty_as_possible(ty);
  66                 return Some(ty);
  67             }
  68             ValueNs::FunctionId(it) => it.into(),
  69             ValueNs::ConstId(it) => it.into(),
  70             ValueNs::StaticId(it) => it.into(),
  71             ValueNs::StructId(it) => {
  72                 self.write_variant_resolution(id, it.into());
  73
  74                 it.into()
  75             }
  76             ValueNs::EnumVariantId(it) => {
  77                 self.write_variant_resolution(id, it.into());
  78
  79                 it.into()
  80             }
  81             ValueNs::ImplSelf(impl_id) => {
  82                 let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
  83                 let substs = generics.type_params_subst(self.db);
  84                 let ty = self.db.impl_self_ty(impl_id).subst(&substs);
  85                 if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
  86                     let ty = self.db.value_ty(struct_id.into()).subst(&substs);
  87                     return Some(ty);
  88                 } else {
  89                     // FIXME: diagnostic, invalid Self reference
  90                     return None;
  91                 }
  92             }
  93             ValueNs::GenericParam(it) => return Some(self.db.const_param_ty(it)),
  94         };
  95
  96         let parent_substs = self_subst.unwrap_or_else(|| Substitution::empty(&Interner));
  97         let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
  98         let substs = ctx.substs_from_path(path, typable, true);
  99         let ty = TyBuilder::value_ty(self.db, typable)
 100             .use_parent_substs(&parent_substs)
 101             .fill(substs.interned(&Interner)[parent_substs.len(&Interner)..].iter().cloned())
 102             .build();
 103         Some(ty)
 104     }
 105
 106     fn resolve_assoc_item(
 107         &mut self,
 108         def: TypeNs,
 109         path: &Path,
 110         remaining_index: usize,
 111         id: ExprOrPatId,
 112     ) -> Option<(ValueNs, Option<Substitution>)> {
 113         assert!(remaining_index < path.segments().len());
 114         // there may be more intermediate segments between the resolved one and
 115         // the end. Only the last segment needs to be resolved to a value; from
 116         // the segments before that, we need to get either a type or a trait ref.
 117
 118         let resolved_segment = path.segments().get(remaining_index - 1).unwrap();
 119         let remaining_segments = path.segments().skip(remaining_index);
 120         let is_before_last = remaining_segments.len() == 1;
 121
 122         match (def, is_before_last) {
 123             (TypeNs::TraitId(trait_), true) => {
 124                 let segment =
 125                     remaining_segments.last().expect("there should be at least one segment here");
 126                 let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
 127                 let trait_ref =
 128                     ctx.lower_trait_ref_from_resolved_path(trait_, resolved_segment, None);
 129                 self.resolve_trait_assoc_item(trait_ref, segment, id)
 130             }
 131             (def, _) => {
 132                 // Either we already have a type (e.g. `Vec::new`), or we have a
 133                 // trait but it's not the last segment, so the next segment
 134                 // should resolve to an associated type of that trait (e.g. `<T
 135                 // as Iterator>::Item::default`)
 136                 let remaining_segments_for_ty =
 137                     remaining_segments.take(remaining_segments.len() - 1);
 138                 let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
 139                 let (ty, _) = ctx.lower_partly_resolved_path(
 140                     def,
 141                     resolved_segment,
 142                     remaining_segments_for_ty,
 143                     true,
 144                 );
 145                 if let TyKind::Unknown = ty.kind(&Interner) {
 146                     return None;
 147                 }
 148
 149                 let ty = self.insert_type_vars(ty);
 150                 let ty = self.normalize_associated_types_in(ty);
 151
 152                 let segment =
 153                     remaining_segments.last().expect("there should be at least one segment here");
 154
 155                 self.resolve_ty_assoc_item(ty, &segment.name, id)
 156             }
 157         }
 158     }
 159
 160     fn resolve_trait_assoc_item(
 161         &mut self,
 162         trait_ref: TraitRef,
 163         segment: PathSegment<'_>,
 164         id: ExprOrPatId,
 165     ) -> Option<(ValueNs, Option<Substitution>)> {
 166         let trait_ = trait_ref.hir_trait_id();
 167         let item =
 168             self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|item| {
 169                 match item {
 170                     AssocItemId::FunctionId(func) => {
 171                         if segment.name == &self.db.function_data(func).name {
 172                             Some(AssocItemId::FunctionId(func))
 173                         } else {
 174                             None
 175                         }
 176                     }
 177
 178                     AssocItemId::ConstId(konst) => {
 179                         if self
 180                             .db
 181                             .const_data(konst)
 182                             .name
 183                             .as_ref()
 184                             .map_or(false, |n| n == segment.name)
 185                         {
 186                             Some(AssocItemId::ConstId(konst))
 187                         } else {
 188                             None
 189                         }
 190                     }
 191                     AssocItemId::TypeAliasId(_) => None,
 192                 }
 193             })?;
 194         let def = match item {
 195             AssocItemId::FunctionId(f) => ValueNs::FunctionId(f),
 196             AssocItemId::ConstId(c) => ValueNs::ConstId(c),
 197             AssocItemId::TypeAliasId(_) => unreachable!(),
 198         };
 199
 200         self.write_assoc_resolution(id, item);
 201         Some((def, Some(trait_ref.substitution)))
 202     }
 203
 204     fn resolve_ty_assoc_item(
 205         &mut self,
 206         ty: Ty,
 207         name: &Name,
 208         id: ExprOrPatId,
 209     ) -> Option<(ValueNs, Option<Substitution>)> {
 210         if let TyKind::Unknown = ty.kind(&Interner) {
 211             return None;
 212         }
 213
 214         if let Some(result) = self.resolve_enum_variant_on_ty(&ty, name, id) {
 215             return Some(result);
 216         }
 217
 218         let canonical_ty = self.canonicalizer().canonicalize_ty(ty.clone());
 219         let krate = self.resolver.krate()?;
 220         let traits_in_scope = self.resolver.traits_in_scope(self.db.upcast());
 221
 222         method_resolution::iterate_method_candidates(
 223             &canonical_ty.value,
 224             self.db,
 225             self.trait_env.clone(),
 226             krate,
 227             &traits_in_scope,
 228             None,
 229             Some(name),
 230             method_resolution::LookupMode::Path,
 231             move |_ty, item| {
 232                 let (def, container) = match item {
 233                     AssocItemId::FunctionId(f) => {
 234                         (ValueNs::FunctionId(f), f.lookup(self.db.upcast()).container)
 235                     }
 236                     AssocItemId::ConstId(c) => {
 237                         (ValueNs::ConstId(c), c.lookup(self.db.upcast()).container)
 238                     }
 239                     AssocItemId::TypeAliasId(_) => unreachable!(),
 240                 };
 241                 let substs = match container {
 242                     AssocContainerId::ImplId(impl_id) => {
 243                         let impl_substs = TyBuilder::subst_for_def(self.db, impl_id)
 244                             .fill(iter::repeat_with(|| self.table.new_type_var()))
 245                             .build();
 246                         let impl_self_ty = self.db.impl_self_ty(impl_id).subst(&impl_substs);
 247                         self.unify(&impl_self_ty, &ty);
 248                         Some(impl_substs)
 249                     }
 250                     AssocContainerId::TraitId(trait_) => {
 251                         // we're picking this method
 252                         let trait_ref = TyBuilder::trait_ref(self.db, trait_)
 253                             .push(ty.clone())
 254                             .fill(std::iter::repeat_with(|| self.table.new_type_var()))
 255                             .build();
 256                         self.push_obligation(trait_ref.clone().cast(&Interner));
 257                         Some(trait_ref.substitution)
 258                     }
 259                     AssocContainerId::ModuleId(_) => None,
 260                 };
 261
 262                 self.write_assoc_resolution(id, item);
 263                 Some((def, substs))
 264             },
 265         )
 266     }
 267
 268     fn resolve_enum_variant_on_ty(
 269         &mut self,
 270         ty: &Ty,
 271         name: &Name,
 272         id: ExprOrPatId,
 273     ) -> Option<(ValueNs, Option<Substitution>)> {
 274         let (enum_id, subst) = match ty.as_adt() {
 275             Some((AdtId::EnumId(e), subst)) => (e, subst),
 276             _ => return None,
 277         };
 278         let enum_data = self.db.enum_data(enum_id);
 279         let local_id = enum_data.variant(name)?;
 280         let variant = EnumVariantId { parent: enum_id, local_id };
 281         self.write_variant_resolution(id, variant.into());
 282         Some((ValueNs::EnumVariantId(variant), Some(subst.clone())))
 283     }
 284 }