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