crates/ra_hir/src/ty/lower.rs

   1 //! Methods for lowering the HIR to types. There are two main cases here:
   2 //!
   3 //!  - Lowering a type reference like `&usize` or `Option<foo::bar::Baz>` to a
   4 //!    type: The entry point for this is `Ty::from_hir`.
   5 //!  - Building the type for an item: This happens through the `type_for_def` query.
   6 //!
   7 //! This usually involves resolving names, collecting generic arguments etc.
   8 use std::iter;
   9 use std::sync::Arc;
  10
  11 use super::{FnSig, GenericPredicate, Substs, TraitRef, Ty, TypeCtor};
  12 use crate::{
  13     adt::VariantDef,
  14     generics::HasGenericParams,
  15     generics::{GenericDef, WherePredicate},
  16     nameres::Namespace,
  17     path::{GenericArg, PathSegment},
  18     resolve::{Resolution, Resolver},
  19     ty::AdtDef,
  20     type_ref::TypeRef,
  21     BuiltinType, Const, Enum, EnumVariant, Function, HirDatabase, ModuleDef, Path, Static, Struct,
  22     StructField, Trait, TypeAlias, Union,
  23 };
  24
  25 impl Ty {
  26     pub(crate) fn from_hir(db: &impl HirDatabase, resolver: &Resolver, type_ref: &TypeRef) -> Self {
  27         match type_ref {
  28             TypeRef::Never => Ty::simple(TypeCtor::Never),
  29             TypeRef::Tuple(inner) => {
  30                 let inner_tys =
  31                     inner.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
  32                 Ty::apply(
  33                     TypeCtor::Tuple { cardinality: inner_tys.len() as u16 },
  34                     Substs(inner_tys.into()),
  35                 )
  36             }
  37             TypeRef::Path(path) => Ty::from_hir_path(db, resolver, path),
  38             TypeRef::RawPtr(inner, mutability) => {
  39                 let inner_ty = Ty::from_hir(db, resolver, inner);
  40                 Ty::apply_one(TypeCtor::RawPtr(*mutability), inner_ty)
  41             }
  42             TypeRef::Array(inner) => {
  43                 let inner_ty = Ty::from_hir(db, resolver, inner);
  44                 Ty::apply_one(TypeCtor::Array, inner_ty)
  45             }
  46             TypeRef::Slice(inner) => {
  47                 let inner_ty = Ty::from_hir(db, resolver, inner);
  48                 Ty::apply_one(TypeCtor::Slice, inner_ty)
  49             }
  50             TypeRef::Reference(inner, mutability) => {
  51                 let inner_ty = Ty::from_hir(db, resolver, inner);
  52                 Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
  53             }
  54             TypeRef::Placeholder => Ty::Unknown,
  55             TypeRef::Fn(params) => {
  56                 let inner_tys =
  57                     params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
  58                 let sig = Substs(inner_tys.into());
  59                 Ty::apply(TypeCtor::FnPtr { num_args: sig.len() as u16 - 1 }, sig)
  60             }
  61             TypeRef::Error => Ty::Unknown,
  62         }
  63     }
  64
  65     pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Self {
  66         // Resolve the path (in type namespace)
  67         let resolution = resolver.resolve_path_without_assoc_items(db, path).take_types();
  68
  69         let def = match resolution {
  70             Some(Resolution::Def(def)) => def,
  71             Some(Resolution::LocalBinding(..)) => {
  72                 // this should never happen
  73                 panic!("path resolved to local binding in type ns");
  74             }
  75             Some(Resolution::GenericParam(idx)) => {
  76                 return Ty::Param {
  77                     idx,
  78                     // FIXME: maybe return name in resolution?
  79                     name: path
  80                         .as_ident()
  81                         .expect("generic param should be single-segment path")
  82                         .clone(),
  83                 };
  84             }
  85             Some(Resolution::SelfType(impl_block)) => {
  86                 return impl_block.target_ty(db);
  87             }
  88             None => return Ty::Unknown,
  89         };
  90
  91         let typable: TypableDef = match def.into() {
  92             None => return Ty::Unknown,
  93             Some(it) => it,
  94         };
  95         let ty = db.type_for_def(typable, Namespace::Types);
  96         let substs = Ty::substs_from_path(db, resolver, path, typable);
  97         ty.subst(&substs)
  98     }
  99
 100     pub(super) fn substs_from_path_segment(
 101         db: &impl HirDatabase,
 102         resolver: &Resolver,
 103         segment: &PathSegment,
 104         resolved: TypableDef,
 105     ) -> Substs {
 106         let def_generic: Option<GenericDef> = match resolved {
 107             TypableDef::Function(func) => Some(func.into()),
 108             TypableDef::Struct(s) => Some(s.into()),
 109             TypableDef::Union(u) => Some(u.into()),
 110             TypableDef::Enum(e) => Some(e.into()),
 111             TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()),
 112             TypableDef::TypeAlias(t) => Some(t.into()),
 113             TypableDef::Const(_) | TypableDef::Static(_) | TypableDef::BuiltinType(_) => None,
 114         };
 115         substs_from_path_segment(db, resolver, segment, def_generic, false)
 116     }
 117
 118     /// Collect generic arguments from a path into a `Substs`. See also
 119     /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
 120     pub(super) fn substs_from_path(
 121         db: &impl HirDatabase,
 122         resolver: &Resolver,
 123         path: &Path,
 124         resolved: TypableDef,
 125     ) -> Substs {
 126         let last = path.segments.last().expect("path should have at least one segment");
 127         let segment = match resolved {
 128             TypableDef::Function(_)
 129             | TypableDef::Struct(_)
 130             | TypableDef::Union(_)
 131             | TypableDef::Enum(_)
 132             | TypableDef::Const(_)
 133             | TypableDef::Static(_)
 134             | TypableDef::TypeAlias(_)
 135             | TypableDef::BuiltinType(_) => last,
 136             TypableDef::EnumVariant(_) => {
 137                 // the generic args for an enum variant may be either specified
 138                 // on the segment referring to the enum, or on the segment
 139                 // referring to the variant. So `Option::<T>::None` and
 140                 // `Option::None::<T>` are both allowed (though the former is
 141                 // preferred). See also `def_ids_for_path_segments` in rustc.
 142                 let len = path.segments.len();
 143                 let segment = if len >= 2 && path.segments[len - 2].args_and_bindings.is_some() {
 144                     // Option::<T>::None
 145                     &path.segments[len - 2]
 146                 } else {
 147                     // Option::None::<T>
 148                     last
 149                 };
 150                 segment
 151             }
 152         };
 153         Ty::substs_from_path_segment(db, resolver, segment, resolved)
 154     }
 155 }
 156
 157 pub(super) fn substs_from_path_segment(
 158     db: &impl HirDatabase,
 159     resolver: &Resolver,
 160     segment: &PathSegment,
 161     def_generic: Option<GenericDef>,
 162     add_self_param: bool,
 163 ) -> Substs {
 164     let mut substs = Vec::new();
 165     let def_generics = def_generic.map(|def| def.generic_params(db)).unwrap_or_default();
 166
 167     let parent_param_count = def_generics.count_parent_params();
 168     substs.extend(iter::repeat(Ty::Unknown).take(parent_param_count));
 169     if add_self_param {
 170         // FIXME this add_self_param argument is kind of a hack: Traits have the
 171         // Self type as an implicit first type parameter, but it can't be
 172         // actually provided in the type arguments
 173         // (well, actually sometimes it can, in the form of type-relative paths: `<Foo as Default>::default()`)
 174         substs.push(Ty::Unknown);
 175     }
 176     if let Some(generic_args) = &segment.args_and_bindings {
 177         // if args are provided, it should be all of them, but we can't rely on that
 178         let self_param_correction = if add_self_param { 1 } else { 0 };
 179         let param_count = def_generics.params.len() - self_param_correction;
 180         for arg in generic_args.args.iter().take(param_count) {
 181             match arg {
 182                 GenericArg::Type(type_ref) => {
 183                     let ty = Ty::from_hir(db, resolver, type_ref);
 184                     substs.push(ty);
 185                 }
 186             }
 187         }
 188     }
 189     // add placeholders for args that were not provided
 190     let supplied_params = substs.len();
 191     for _ in supplied_params..def_generics.count_params_including_parent() {
 192         substs.push(Ty::Unknown);
 193     }
 194     assert_eq!(substs.len(), def_generics.count_params_including_parent());
 195
 196     // handle defaults
 197     if let Some(def_generic) = def_generic {
 198         let default_substs = db.generic_defaults(def_generic);
 199         assert_eq!(substs.len(), default_substs.len());
 200
 201         for (i, default_ty) in default_substs.iter().enumerate() {
 202             if substs[i] == Ty::Unknown {
 203                 substs[i] = default_ty.clone();
 204             }
 205         }
 206     }
 207
 208     Substs(substs.into())
 209 }
 210
 211 impl TraitRef {
 212     pub(crate) fn from_path(
 213         db: &impl HirDatabase,
 214         resolver: &Resolver,
 215         path: &Path,
 216         explicit_self_ty: Option<Ty>,
 217     ) -> Option<Self> {
 218         let resolved = match resolver.resolve_path_without_assoc_items(db, &path).take_types()? {
 219             Resolution::Def(ModuleDef::Trait(tr)) => tr,
 220             _ => return None,
 221         };
 222         let mut substs = Self::substs_from_path(db, resolver, path, resolved);
 223         if let Some(self_ty) = explicit_self_ty {
 224             // FIXME this could be nicer
 225             let mut substs_vec = substs.0.to_vec();
 226             substs_vec[0] = self_ty;
 227             substs.0 = substs_vec.into();
 228         }
 229         Some(TraitRef { trait_: resolved, substs })
 230     }
 231
 232     pub(crate) fn from_hir(
 233         db: &impl HirDatabase,
 234         resolver: &Resolver,
 235         type_ref: &TypeRef,
 236         explicit_self_ty: Option<Ty>,
 237     ) -> Option<Self> {
 238         let path = match type_ref {
 239             TypeRef::Path(path) => path,
 240             _ => return None,
 241         };
 242         TraitRef::from_path(db, resolver, path, explicit_self_ty)
 243     }
 244
 245     fn substs_from_path(
 246         db: &impl HirDatabase,
 247         resolver: &Resolver,
 248         path: &Path,
 249         resolved: Trait,
 250     ) -> Substs {
 251         let segment = path.segments.last().expect("path should have at least one segment");
 252         substs_from_path_segment(db, resolver, segment, Some(resolved.into()), true)
 253     }
 254
 255     pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef {
 256         let substs = Substs::identity(&trait_.generic_params(db));
 257         TraitRef { trait_, substs }
 258     }
 259
 260     pub(crate) fn for_where_predicate(
 261         db: &impl HirDatabase,
 262         resolver: &Resolver,
 263         pred: &WherePredicate,
 264     ) -> Option<TraitRef> {
 265         let self_ty = Ty::from_hir(db, resolver, &pred.type_ref);
 266         TraitRef::from_path(db, resolver, &pred.trait_ref, Some(self_ty))
 267     }
 268 }
 269
 270 /// Build the declared type of an item. This depends on the namespace; e.g. for
 271 /// `struct Foo(usize)`, we have two types: The type of the struct itself, and
 272 /// the constructor function `(usize) -> Foo` which lives in the values
 273 /// namespace.
 274 pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace) -> Ty {
 275     match (def, ns) {
 276         (TypableDef::Function(f), Namespace::Values) => type_for_fn(db, f),
 277         (TypableDef::Struct(s), Namespace::Types) => type_for_adt(db, s),
 278         (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s),
 279         (TypableDef::Enum(e), Namespace::Types) => type_for_adt(db, e),
 280         (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v),
 281         (TypableDef::Union(u), Namespace::Types) => type_for_adt(db, u),
 282         (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t),
 283         (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c),
 284         (TypableDef::Static(c), Namespace::Values) => type_for_static(db, c),
 285         (TypableDef::BuiltinType(t), Namespace::Types) => type_for_builtin(t),
 286
 287         // 'error' cases:
 288         (TypableDef::Function(_), Namespace::Types) => Ty::Unknown,
 289         (TypableDef::Union(_), Namespace::Values) => Ty::Unknown,
 290         (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown,
 291         (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown,
 292         (TypableDef::TypeAlias(_), Namespace::Values) => Ty::Unknown,
 293         (TypableDef::Const(_), Namespace::Types) => Ty::Unknown,
 294         (TypableDef::Static(_), Namespace::Types) => Ty::Unknown,
 295         (TypableDef::BuiltinType(_), Namespace::Values) => Ty::Unknown,
 296     }
 297 }
 298
 299 /// Build the signature of a callable item (function, struct or enum variant).
 300 pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
 301     match def {
 302         CallableDef::Function(f) => fn_sig_for_fn(db, f),
 303         CallableDef::Struct(s) => fn_sig_for_struct_constructor(db, s),
 304         CallableDef::EnumVariant(e) => fn_sig_for_enum_variant_constructor(db, e),
 305     }
 306 }
 307
 308 /// Build the type of a specific field of a struct or enum variant.
 309 pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
 310     let parent_def = field.parent_def(db);
 311     let resolver = match parent_def {
 312         VariantDef::Struct(it) => it.resolver(db),
 313         VariantDef::EnumVariant(it) => it.parent_enum(db).resolver(db),
 314     };
 315     let var_data = parent_def.variant_data(db);
 316     let type_ref = &var_data.fields().unwrap()[field.id].type_ref;
 317     Ty::from_hir(db, &resolver, type_ref)
 318 }
 319
 320 pub(crate) fn trait_env(
 321     db: &impl HirDatabase,
 322     resolver: &Resolver,
 323 ) -> Arc<super::TraitEnvironment> {
 324     let predicates = resolver
 325         .where_predicates_in_scope()
 326         .map(|pred| {
 327             TraitRef::for_where_predicate(db, &resolver, pred)
 328                 .map_or(GenericPredicate::Error, GenericPredicate::Implemented)
 329         })
 330         .collect::<Vec<_>>();
 331
 332     Arc::new(super::TraitEnvironment { predicates })
 333 }
 334
 335 /// Resolve the where clause(s) of an item with generics.
 336 pub(crate) fn generic_predicates_query(
 337     db: &impl HirDatabase,
 338     def: GenericDef,
 339 ) -> Arc<[GenericPredicate]> {
 340     let resolver = def.resolver(db);
 341     let predicates = resolver
 342         .where_predicates_in_scope()
 343         .map(|pred| {
 344             TraitRef::for_where_predicate(db, &resolver, pred)
 345                 .map_or(GenericPredicate::Error, GenericPredicate::Implemented)
 346         })
 347         .collect::<Vec<_>>();
 348     predicates.into()
 349 }
 350
 351 /// Resolve the default type params from generics
 352 pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) -> Substs {
 353     let resolver = def.resolver(db);
 354     let generic_params = def.generic_params(db);
 355
 356     let defaults = generic_params
 357         .params_including_parent()
 358         .into_iter()
 359         .map(|p| {
 360             p.default.as_ref().map_or(Ty::Unknown, |path| Ty::from_hir_path(db, &resolver, path))
 361         })
 362         .collect::<Vec<_>>();
 363
 364     Substs(defaults.into())
 365 }
 366
 367 fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
 368     let data = def.data(db);
 369     let resolver = def.resolver(db);
 370     let params = data.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
 371     let ret = Ty::from_hir(db, &resolver, data.ret_type());
 372     FnSig::from_params_and_return(params, ret)
 373 }
 374
 375 /// Build the declared type of a function. This should not need to look at the
 376 /// function body.
 377 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
 378     let generics = def.generic_params(db);
 379     let substs = Substs::identity(&generics);
 380     Ty::apply(TypeCtor::FnDef(def.into()), substs)
 381 }
 382
 383 /// Build the declared type of a const.
 384 fn type_for_const(db: &impl HirDatabase, def: Const) -> Ty {
 385     let data = def.data(db);
 386     let resolver = def.resolver(db);
 387
 388     Ty::from_hir(db, &resolver, data.type_ref())
 389 }
 390
 391 /// Build the declared type of a static.
 392 fn type_for_static(db: &impl HirDatabase, def: Static) -> Ty {
 393     let data = def.data(db);
 394     let resolver = def.resolver(db);
 395
 396     Ty::from_hir(db, &resolver, data.type_ref())
 397 }
 398
 399 /// Build the declared type of a static.
 400 fn type_for_builtin(def: BuiltinType) -> Ty {
 401     Ty::simple(match def {
 402         BuiltinType::Char => TypeCtor::Char,
 403         BuiltinType::Bool => TypeCtor::Bool,
 404         BuiltinType::Str => TypeCtor::Str,
 405         BuiltinType::Int(ty) => TypeCtor::Int(ty.into()),
 406         BuiltinType::Float(ty) => TypeCtor::Float(ty.into()),
 407     })
 408 }
 409
 410 fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
 411     let var_data = def.variant_data(db);
 412     let fields = match var_data.fields() {
 413         Some(fields) => fields,
 414         None => panic!("fn_sig_for_struct_constructor called on unit struct"),
 415     };
 416     let resolver = def.resolver(db);
 417     let params = fields
 418         .iter()
 419         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
 420         .collect::<Vec<_>>();
 421     let ret = type_for_adt(db, def);
 422     FnSig::from_params_and_return(params, ret)
 423 }
 424
 425 /// Build the type of a tuple struct constructor.
 426 fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
 427     let var_data = def.variant_data(db);
 428     if var_data.fields().is_none() {
 429         return type_for_adt(db, def); // Unit struct
 430     }
 431     let generics = def.generic_params(db);
 432     let substs = Substs::identity(&generics);
 433     Ty::apply(TypeCtor::FnDef(def.into()), substs)
 434 }
 435
 436 fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig {
 437     let var_data = def.variant_data(db);
 438     let fields = match var_data.fields() {
 439         Some(fields) => fields,
 440         None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"),
 441     };
 442     let resolver = def.parent_enum(db).resolver(db);
 443     let params = fields
 444         .iter()
 445         .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
 446         .collect::<Vec<_>>();
 447     let generics = def.parent_enum(db).generic_params(db);
 448     let substs = Substs::identity(&generics);
 449     let ret = type_for_adt(db, def.parent_enum(db)).subst(&substs);
 450     FnSig::from_params_and_return(params, ret)
 451 }
 452
 453 /// Build the type of a tuple enum variant constructor.
 454 fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
 455     let var_data = def.variant_data(db);
 456     if var_data.fields().is_none() {
 457         return type_for_adt(db, def.parent_enum(db)); // Unit variant
 458     }
 459     let generics = def.parent_enum(db).generic_params(db);
 460     let substs = Substs::identity(&generics);
 461     Ty::apply(TypeCtor::FnDef(def.into()), substs)
 462 }
 463
 464 fn type_for_adt(db: &impl HirDatabase, adt: impl Into<AdtDef> + HasGenericParams) -> Ty {
 465     let generics = adt.generic_params(db);
 466     Ty::apply(TypeCtor::Adt(adt.into()), Substs::identity(&generics))
 467 }
 468
 469 fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty {
 470     let generics = t.generic_params(db);
 471     let resolver = t.resolver(db);
 472     let type_ref = t.type_ref(db);
 473     let substs = Substs::identity(&generics);
 474     let inner = Ty::from_hir(db, &resolver, &type_ref.unwrap_or(TypeRef::Error));
 475     inner.subst(&substs)
 476 }
 477
 478 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 479 pub enum TypableDef {
 480     Function(Function),
 481     Struct(Struct),
 482     Union(Union),
 483     Enum(Enum),
 484     EnumVariant(EnumVariant),
 485     TypeAlias(TypeAlias),
 486     Const(Const),
 487     Static(Static),
 488     BuiltinType(BuiltinType),
 489 }
 490 impl_froms!(
 491     TypableDef: Function,
 492     Struct,
 493     Union,
 494     Enum,
 495     EnumVariant,
 496     TypeAlias,
 497     Const,
 498     Static,
 499     BuiltinType
 500 );
 501
 502 impl From<ModuleDef> for Option<TypableDef> {
 503     fn from(def: ModuleDef) -> Option<TypableDef> {
 504         let res = match def {
 505             ModuleDef::Function(f) => f.into(),
 506             ModuleDef::Struct(s) => s.into(),
 507             ModuleDef::Union(u) => u.into(),
 508             ModuleDef::Enum(e) => e.into(),
 509             ModuleDef::EnumVariant(v) => v.into(),
 510             ModuleDef::TypeAlias(t) => t.into(),
 511             ModuleDef::Const(v) => v.into(),
 512             ModuleDef::Static(v) => v.into(),
 513             ModuleDef::BuiltinType(t) => t.into(),
 514             ModuleDef::Module(_) | ModuleDef::Trait(_) => return None,
 515         };
 516         Some(res)
 517     }
 518 }
 519
 520 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 521 pub enum CallableDef {
 522     Function(Function),
 523     Struct(Struct),
 524     EnumVariant(EnumVariant),
 525 }
 526 impl_froms!(CallableDef: Function, Struct, EnumVariant);
 527
 528 impl From<CallableDef> for GenericDef {
 529     fn from(def: CallableDef) -> GenericDef {
 530         match def {
 531             CallableDef::Function(f) => f.into(),
 532             CallableDef::Struct(s) => s.into(),
 533             CallableDef::EnumVariant(e) => e.into(),
 534         }
 535     }
 536 }