crates/hir-ty/src/infer/path.rs

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