diff options
Diffstat (limited to 'src/tools/rust-analyzer/crates/hir-ty')
48 files changed, 32374 insertions, 0 deletions
diff --git a/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml new file mode 100644 index 000000000..5cd444c1a --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml @@ -0,0 +1,44 @@ +[package] +name = "hir-ty" +version = "0.0.0" +description = "TBD" +license = "MIT OR Apache-2.0" +edition = "2021" +rust-version = "1.57" + +[lib] +doctest = false + +[dependencies] +cov-mark = "2.0.0-pre.1" +itertools = "0.10.3" +arrayvec = "0.7.2" +smallvec = "1.9.0" +ena = "0.14.0" +tracing = "0.1.35" +rustc-hash = "1.1.0" +scoped-tls = "1.0.0" +chalk-solve = { version = "0.83.0", default-features = false } +chalk-ir = "0.83.0" +chalk-recursive = { version = "0.83.0", default-features = false } +la-arena = { version = "0.3.0", path = "../../lib/la-arena" } +once_cell = "1.12.0" +typed-arena = "2.0.1" + +stdx = { path = "../stdx", version = "0.0.0" } +hir-def = { path = "../hir-def", version = "0.0.0" } +hir-expand = { path = "../hir-expand", version = "0.0.0" } +base-db = { path = "../base-db", version = "0.0.0" } +profile = { path = "../profile", version = "0.0.0" } +syntax = { path = "../syntax", version = "0.0.0" } +limit = { path = "../limit", version = "0.0.0" } + +[dev-dependencies] +test-utils = { path = "../test-utils" } +expect-test = "1.4.0" +tracing = "0.1.35" +tracing-subscriber = { version = "0.3.14", default-features = false, features = [ + "env-filter", + "registry", +] } +tracing-tree = "0.2.1" diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs new file mode 100644 index 000000000..b6f226dbf --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs @@ -0,0 +1,145 @@ +//! In certain situations, rust automatically inserts derefs as necessary: for +//! example, field accesses `foo.bar` still work when `foo` is actually a +//! reference to a type with the field `bar`. This is an approximation of the +//! logic in rustc (which lives in librustc_typeck/check/autoderef.rs). + +use std::sync::Arc; + +use chalk_ir::cast::Cast; +use hir_expand::name::name; +use limit::Limit; +use syntax::SmolStr; + +use crate::{ + db::HirDatabase, infer::unify::InferenceTable, Canonical, Goal, Interner, ProjectionTyExt, + TraitEnvironment, Ty, TyBuilder, TyKind, +}; + +static AUTODEREF_RECURSION_LIMIT: Limit = Limit::new(10); + +pub(crate) enum AutoderefKind { + Builtin, + Overloaded, +} + +pub(crate) struct Autoderef<'a, 'db> { + pub(crate) table: &'a mut InferenceTable<'db>, + ty: Ty, + at_start: bool, + steps: Vec<(AutoderefKind, Ty)>, +} + +impl<'a, 'db> Autoderef<'a, 'db> { + pub(crate) fn new(table: &'a mut InferenceTable<'db>, ty: Ty) -> Self { + let ty = table.resolve_ty_shallow(&ty); + Autoderef { table, ty, at_start: true, steps: Vec::new() } + } + + pub(crate) fn step_count(&self) -> usize { + self.steps.len() + } + + pub(crate) fn steps(&self) -> &[(AutoderefKind, Ty)] { + &self.steps + } + + pub(crate) fn final_ty(&self) -> Ty { + self.ty.clone() + } +} + +impl Iterator for Autoderef<'_, '_> { + type Item = (Ty, usize); + + fn next(&mut self) -> Option<Self::Item> { + if self.at_start { + self.at_start = false; + return Some((self.ty.clone(), 0)); + } + + if AUTODEREF_RECURSION_LIMIT.check(self.steps.len() + 1).is_err() { + return None; + } + + let (kind, new_ty) = autoderef_step(self.table, self.ty.clone())?; + + self.steps.push((kind, self.ty.clone())); + self.ty = new_ty; + + Some((self.ty.clone(), self.step_count())) + } +} + +pub(crate) fn autoderef_step( + table: &mut InferenceTable<'_>, + ty: Ty, +) -> Option<(AutoderefKind, Ty)> { + if let Some(derefed) = builtin_deref(&ty) { + Some((AutoderefKind::Builtin, table.resolve_ty_shallow(derefed))) + } else { + Some((AutoderefKind::Overloaded, deref_by_trait(table, ty)?)) + } +} + +// FIXME: replace uses of this with Autoderef above +pub fn autoderef<'a>( + db: &'a dyn HirDatabase, + env: Arc<TraitEnvironment>, + ty: Canonical<Ty>, +) -> impl Iterator<Item = Canonical<Ty>> + 'a { + let mut table = InferenceTable::new(db, env); + let ty = table.instantiate_canonical(ty); + let mut autoderef = Autoderef::new(&mut table, ty); + let mut v = Vec::new(); + while let Some((ty, _steps)) = autoderef.next() { + v.push(autoderef.table.canonicalize(ty).value); + } + v.into_iter() +} + +pub(crate) fn deref(table: &mut InferenceTable<'_>, ty: Ty) -> Option<Ty> { + let _p = profile::span("deref"); + autoderef_step(table, ty).map(|(_, ty)| ty) +} + +fn builtin_deref(ty: &Ty) -> Option<&Ty> { + match ty.kind(Interner) { + TyKind::Ref(.., ty) => Some(ty), + TyKind::Raw(.., ty) => Some(ty), + _ => None, + } +} + +fn deref_by_trait(table: &mut InferenceTable<'_>, ty: Ty) -> Option<Ty> { + let _p = profile::span("deref_by_trait"); + if table.resolve_ty_shallow(&ty).inference_var(Interner).is_some() { + // don't try to deref unknown variables + return None; + } + + let db = table.db; + let deref_trait = db + .lang_item(table.trait_env.krate, SmolStr::new_inline("deref")) + .and_then(|l| l.as_trait())?; + let target = db.trait_data(deref_trait).associated_type_by_name(&name![Target])?; + + let projection = { + let b = TyBuilder::assoc_type_projection(db, target); + if b.remaining() != 1 { + // the Target type + Deref trait should only have one generic parameter, + // namely Deref's Self type + return None; + } + b.push(ty).build() + }; + + // Check that the type implements Deref at all + let trait_ref = projection.trait_ref(db); + let implements_goal: Goal = trait_ref.cast(Interner); + table.try_obligation(implements_goal.clone())?; + + table.register_obligation(implements_goal); + + let result = table.normalize_projection_ty(projection); + Some(table.resolve_ty_shallow(&result)) +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs new file mode 100644 index 000000000..94d7806cb --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs @@ -0,0 +1,311 @@ +//! `TyBuilder`, a helper for building instances of `Ty` and related types. + +use std::iter; + +use chalk_ir::{ + cast::{Cast, CastTo, Caster}, + fold::TypeFoldable, + interner::HasInterner, + AdtId, BoundVar, DebruijnIndex, Scalar, +}; +use hir_def::{ + builtin_type::BuiltinType, generics::TypeOrConstParamData, ConstParamId, GenericDefId, TraitId, + TypeAliasId, +}; +use smallvec::SmallVec; + +use crate::{ + consteval::unknown_const_as_generic, db::HirDatabase, infer::unify::InferenceTable, primitive, + to_assoc_type_id, to_chalk_trait_id, utils::generics, Binders, CallableSig, ConstData, + ConstValue, GenericArg, GenericArgData, Interner, ProjectionTy, Substitution, TraitRef, Ty, + TyDefId, TyExt, TyKind, ValueTyDefId, +}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ParamKind { + Type, + Const(Ty), +} + +/// This is a builder for `Ty` or anything that needs a `Substitution`. +pub struct TyBuilder<D> { + /// The `data` field is used to keep track of what we're building (e.g. an + /// ADT, a `TraitRef`, ...). + data: D, + vec: SmallVec<[GenericArg; 2]>, + param_kinds: SmallVec<[ParamKind; 2]>, +} + +impl<A> TyBuilder<A> { + fn with_data<B>(self, data: B) -> TyBuilder<B> { + TyBuilder { data, param_kinds: self.param_kinds, vec: self.vec } + } +} + +impl<D> TyBuilder<D> { + fn new(data: D, param_kinds: SmallVec<[ParamKind; 2]>) -> TyBuilder<D> { + TyBuilder { data, vec: SmallVec::with_capacity(param_kinds.len()), param_kinds } + } + + fn build_internal(self) -> (D, Substitution) { + assert_eq!(self.vec.len(), self.param_kinds.len()); + for (a, e) in self.vec.iter().zip(self.param_kinds.iter()) { + self.assert_match_kind(a, e); + } + let subst = Substitution::from_iter(Interner, self.vec); + (self.data, subst) + } + + pub fn push(mut self, arg: impl CastTo<GenericArg>) -> Self { + let arg = arg.cast(Interner); + let expected_kind = &self.param_kinds[self.vec.len()]; + let arg_kind = match arg.data(Interner) { + chalk_ir::GenericArgData::Ty(_) => ParamKind::Type, + chalk_ir::GenericArgData::Lifetime(_) => panic!("Got lifetime in TyBuilder::push"), + chalk_ir::GenericArgData::Const(c) => { + let c = c.data(Interner); + ParamKind::Const(c.ty.clone()) + } + }; + assert_eq!(*expected_kind, arg_kind); + self.vec.push(arg); + self + } + + pub fn remaining(&self) -> usize { + self.param_kinds.len() - self.vec.len() + } + + pub fn fill_with_bound_vars(self, debruijn: DebruijnIndex, starting_from: usize) -> Self { + // self.fill is inlined to make borrow checker happy + let mut this = self; + let other = this.param_kinds.iter().skip(this.vec.len()); + let filler = (starting_from..).zip(other).map(|(idx, kind)| match kind { + ParamKind::Type => { + GenericArgData::Ty(TyKind::BoundVar(BoundVar::new(debruijn, idx)).intern(Interner)) + .intern(Interner) + } + ParamKind::Const(ty) => GenericArgData::Const( + ConstData { + value: ConstValue::BoundVar(BoundVar::new(debruijn, idx)), + ty: ty.clone(), + } + .intern(Interner), + ) + .intern(Interner), + }); + this.vec.extend(filler.take(this.remaining()).casted(Interner)); + assert_eq!(this.remaining(), 0); + this + } + + pub fn fill_with_unknown(self) -> Self { + // self.fill is inlined to make borrow checker happy + let mut this = self; + let filler = this.param_kinds.iter().skip(this.vec.len()).map(|x| match x { + ParamKind::Type => GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner), + ParamKind::Const(ty) => unknown_const_as_generic(ty.clone()), + }); + this.vec.extend(filler.casted(Interner)); + assert_eq!(this.remaining(), 0); + this + } + + pub(crate) fn fill_with_inference_vars(self, table: &mut InferenceTable<'_>) -> Self { + self.fill(|x| match x { + ParamKind::Type => GenericArgData::Ty(table.new_type_var()).intern(Interner), + ParamKind::Const(ty) => { + GenericArgData::Const(table.new_const_var(ty.clone())).intern(Interner) + } + }) + } + + pub fn fill(mut self, filler: impl FnMut(&ParamKind) -> GenericArg) -> Self { + self.vec.extend(self.param_kinds.iter().skip(self.vec.len()).map(filler)); + assert_eq!(self.remaining(), 0); + self + } + + pub fn use_parent_substs(mut self, parent_substs: &Substitution) -> Self { + assert!(self.vec.is_empty()); + assert!(parent_substs.len(Interner) <= self.param_kinds.len()); + self.extend(parent_substs.iter(Interner).cloned()); + self + } + + fn extend(&mut self, it: impl Iterator<Item = GenericArg> + Clone) { + for x in it.clone().zip(self.param_kinds.iter().skip(self.vec.len())) { + self.assert_match_kind(&x.0, &x.1); + } + self.vec.extend(it); + } + + fn assert_match_kind(&self, a: &chalk_ir::GenericArg<Interner>, e: &ParamKind) { + match (a.data(Interner), e) { + (chalk_ir::GenericArgData::Ty(_), ParamKind::Type) + | (chalk_ir::GenericArgData::Const(_), ParamKind::Const(_)) => (), + _ => panic!("Mismatched kinds: {:?}, {:?}, {:?}", a, self.vec, self.param_kinds), + } + } +} + +impl TyBuilder<()> { + pub fn unit() -> Ty { + TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner) + } + + pub fn usize() -> Ty { + TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(Interner) + } + + pub fn fn_ptr(sig: CallableSig) -> Ty { + TyKind::Function(sig.to_fn_ptr()).intern(Interner) + } + + pub fn builtin(builtin: BuiltinType) -> Ty { + match builtin { + BuiltinType::Char => TyKind::Scalar(Scalar::Char).intern(Interner), + BuiltinType::Bool => TyKind::Scalar(Scalar::Bool).intern(Interner), + BuiltinType::Str => TyKind::Str.intern(Interner), + BuiltinType::Int(t) => { + TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(t))).intern(Interner) + } + BuiltinType::Uint(t) => { + TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(t))).intern(Interner) + } + BuiltinType::Float(t) => { + TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(t))).intern(Interner) + } + } + } + + pub fn slice(argument: Ty) -> Ty { + TyKind::Slice(argument).intern(Interner) + } + + pub fn placeholder_subst(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> Substitution { + let params = generics(db.upcast(), def.into()); + params.placeholder_subst(db) + } + + pub fn subst_for_def(db: &dyn HirDatabase, def: impl Into<GenericDefId>) -> TyBuilder<()> { + let def = def.into(); + let params = generics(db.upcast(), def); + TyBuilder::new( + (), + params + .iter() + .map(|(id, data)| match data { + TypeOrConstParamData::TypeParamData(_) => ParamKind::Type, + TypeOrConstParamData::ConstParamData(_) => { + ParamKind::Const(db.const_param_ty(ConstParamId::from_unchecked(id))) + } + }) + .collect(), + ) + } + + pub fn build(self) -> Substitution { + let ((), subst) = self.build_internal(); + subst + } +} + +impl TyBuilder<hir_def::AdtId> { + pub fn adt(db: &dyn HirDatabase, def: hir_def::AdtId) -> TyBuilder<hir_def::AdtId> { + TyBuilder::subst_for_def(db, def).with_data(def) + } + + pub fn fill_with_defaults( + mut self, + db: &dyn HirDatabase, + mut fallback: impl FnMut() -> Ty, + ) -> Self { + let defaults = db.generic_defaults(self.data.into()); + for default_ty in defaults.iter().skip(self.vec.len()) { + if let GenericArgData::Ty(x) = default_ty.skip_binders().data(Interner) { + if x.is_unknown() { + self.vec.push(fallback().cast(Interner)); + continue; + } + }; + // each default can depend on the previous parameters + let subst_so_far = Substitution::from_iter(Interner, self.vec.clone()); + self.vec.push(default_ty.clone().substitute(Interner, &subst_so_far).cast(Interner)); + } + self + } + + pub fn build(self) -> Ty { + let (adt, subst) = self.build_internal(); + TyKind::Adt(AdtId(adt), subst).intern(Interner) + } +} + +pub struct Tuple(usize); +impl TyBuilder<Tuple> { + pub fn tuple(size: usize) -> TyBuilder<Tuple> { + TyBuilder::new(Tuple(size), iter::repeat(ParamKind::Type).take(size).collect()) + } + + pub fn build(self) -> Ty { + let (Tuple(size), subst) = self.build_internal(); + TyKind::Tuple(size, subst).intern(Interner) + } +} + +impl TyBuilder<TraitId> { + pub fn trait_ref(db: &dyn HirDatabase, def: TraitId) -> TyBuilder<TraitId> { + TyBuilder::subst_for_def(db, def).with_data(def) + } + + pub fn build(self) -> TraitRef { + let (trait_id, substitution) = self.build_internal(); + TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution } + } +} + +impl TyBuilder<TypeAliasId> { + pub fn assoc_type_projection(db: &dyn HirDatabase, def: TypeAliasId) -> TyBuilder<TypeAliasId> { + TyBuilder::subst_for_def(db, def).with_data(def) + } + + pub fn build(self) -> ProjectionTy { + let (type_alias, substitution) = self.build_internal(); + ProjectionTy { associated_ty_id: to_assoc_type_id(type_alias), substitution } + } +} + +impl<T: HasInterner<Interner = Interner> + TypeFoldable<Interner>> TyBuilder<Binders<T>> { + fn subst_binders(b: Binders<T>) -> Self { + let param_kinds = b + .binders + .iter(Interner) + .map(|x| match x { + chalk_ir::VariableKind::Ty(_) => ParamKind::Type, + chalk_ir::VariableKind::Lifetime => panic!("Got lifetime parameter"), + chalk_ir::VariableKind::Const(ty) => ParamKind::Const(ty.clone()), + }) + .collect(); + TyBuilder::new(b, param_kinds) + } + + pub fn build(self) -> T { + let (b, subst) = self.build_internal(); + b.substitute(Interner, &subst) + } +} + +impl TyBuilder<Binders<Ty>> { + pub fn def_ty(db: &dyn HirDatabase, def: TyDefId) -> TyBuilder<Binders<Ty>> { + TyBuilder::subst_binders(db.ty(def)) + } + + pub fn impl_self_ty(db: &dyn HirDatabase, def: hir_def::ImplId) -> TyBuilder<Binders<Ty>> { + TyBuilder::subst_binders(db.impl_self_ty(def)) + } + + pub fn value_ty(db: &dyn HirDatabase, def: ValueTyDefId) -> TyBuilder<Binders<Ty>> { + TyBuilder::subst_binders(db.value_ty(def)) + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs new file mode 100644 index 000000000..faec99c7d --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs @@ -0,0 +1,799 @@ +//! The implementation of `RustIrDatabase` for Chalk, which provides information +//! about the code that Chalk needs. +use std::sync::Arc; + +use cov_mark::hit; +use syntax::SmolStr; +use tracing::debug; + +use chalk_ir::{cast::Cast, fold::shift::Shift, CanonicalVarKinds}; +use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait}; + +use base_db::CrateId; +use hir_def::{ + lang_item::{lang_attr, LangItemTarget}, + AssocItemId, GenericDefId, HasModule, ItemContainerId, Lookup, ModuleId, TypeAliasId, +}; +use hir_expand::name::name; + +use crate::{ + db::HirDatabase, + display::HirDisplay, + from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, make_binders, + make_single_type_binders, + mapping::{from_chalk, ToChalk, TypeAliasAsValue}, + method_resolution::{TraitImpls, TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS}, + to_assoc_type_id, to_chalk_trait_id, + traits::ChalkContext, + utils::generics, + AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, Interner, ProjectionTy, + ProjectionTyExt, QuantifiedWhereClause, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, + TyExt, TyKind, WhereClause, +}; + +pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>; +pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>; +pub(crate) type StructDatum = chalk_solve::rust_ir::AdtDatum<Interner>; +pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>; +pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>; + +pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>; +pub(crate) type TraitId = chalk_ir::TraitId<Interner>; +pub(crate) type AdtId = chalk_ir::AdtId<Interner>; +pub(crate) type ImplId = chalk_ir::ImplId<Interner>; +pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>; +pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>; +pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>; +pub(crate) type Variances = chalk_ir::Variances<Interner>; + +impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> { + fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> { + self.db.associated_ty_data(id) + } + fn trait_datum(&self, trait_id: TraitId) -> Arc<TraitDatum> { + self.db.trait_datum(self.krate, trait_id) + } + fn adt_datum(&self, struct_id: AdtId) -> Arc<StructDatum> { + self.db.struct_datum(self.krate, struct_id) + } + fn adt_repr(&self, _struct_id: AdtId) -> Arc<rust_ir::AdtRepr<Interner>> { + // FIXME: keep track of these + Arc::new(rust_ir::AdtRepr { c: false, packed: false, int: None }) + } + fn discriminant_type(&self, _ty: chalk_ir::Ty<Interner>) -> chalk_ir::Ty<Interner> { + // FIXME: keep track of this + chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::U32)).intern(Interner) + } + fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> { + self.db.impl_datum(self.krate, impl_id) + } + + fn fn_def_datum( + &self, + fn_def_id: chalk_ir::FnDefId<Interner>, + ) -> Arc<rust_ir::FnDefDatum<Interner>> { + self.db.fn_def_datum(self.krate, fn_def_id) + } + + fn impls_for_trait( + &self, + trait_id: TraitId, + parameters: &[chalk_ir::GenericArg<Interner>], + binders: &CanonicalVarKinds<Interner>, + ) -> Vec<ImplId> { + debug!("impls_for_trait {:?}", trait_id); + let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id); + + let ty: Ty = parameters[0].assert_ty_ref(Interner).clone(); + + fn binder_kind( + ty: &Ty, + binders: &CanonicalVarKinds<Interner>, + ) -> Option<chalk_ir::TyVariableKind> { + if let TyKind::BoundVar(bv) = ty.kind(Interner) { + let binders = binders.as_slice(Interner); + if bv.debruijn == DebruijnIndex::INNERMOST { + if let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind { + return Some(tk); + } + } + } + None + } + + let self_ty_fp = TyFingerprint::for_trait_impl(&ty); + let fps: &[TyFingerprint] = match binder_kind(&ty, binders) { + Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS, + Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS, + _ => self_ty_fp.as_ref().map(std::slice::from_ref).unwrap_or(&[]), + }; + + fn local_impls(db: &dyn HirDatabase, module: ModuleId) -> Option<Arc<TraitImpls>> { + let block = module.containing_block()?; + hit!(block_local_impls); + db.trait_impls_in_block(block) + } + + // Note: Since we're using impls_for_trait, only impls where the trait + // can be resolved should ever reach Chalk. impl_datum relies on that + // and will panic if the trait can't be resolved. + let in_deps = self.db.trait_impls_in_deps(self.krate); + let in_self = self.db.trait_impls_in_crate(self.krate); + let trait_module = trait_.module(self.db.upcast()); + let type_module = match self_ty_fp { + Some(TyFingerprint::Adt(adt_id)) => Some(adt_id.module(self.db.upcast())), + Some(TyFingerprint::ForeignType(type_id)) => { + Some(from_foreign_def_id(type_id).module(self.db.upcast())) + } + Some(TyFingerprint::Dyn(trait_id)) => Some(trait_id.module(self.db.upcast())), + _ => None, + }; + let impl_maps = [ + Some(in_deps), + Some(in_self), + local_impls(self.db, trait_module), + type_module.and_then(|m| local_impls(self.db, m)), + ]; + + let id_to_chalk = |id: hir_def::ImplId| id.to_chalk(self.db); + + let result: Vec<_> = if fps.is_empty() { + debug!("Unrestricted search for {:?} impls...", trait_); + impl_maps + .iter() + .filter_map(|o| o.as_ref()) + .flat_map(|impls| impls.for_trait(trait_).map(id_to_chalk)) + .collect() + } else { + impl_maps + .iter() + .filter_map(|o| o.as_ref()) + .flat_map(|impls| { + fps.iter().flat_map(move |fp| { + impls.for_trait_and_self_ty(trait_, *fp).map(id_to_chalk) + }) + }) + .collect() + }; + + debug!("impls_for_trait returned {} impls", result.len()); + result + } + fn impl_provided_for(&self, auto_trait_id: TraitId, kind: &chalk_ir::TyKind<Interner>) -> bool { + debug!("impl_provided_for {:?}, {:?}", auto_trait_id, kind); + false // FIXME + } + fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> { + self.db.associated_ty_value(self.krate, id) + } + + fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<Interner>> { + vec![] + } + fn local_impls_to_coherence_check(&self, _trait_id: TraitId) -> Vec<ImplId> { + // We don't do coherence checking (yet) + unimplemented!() + } + fn interner(&self) -> Interner { + Interner + } + fn well_known_trait_id( + &self, + well_known_trait: rust_ir::WellKnownTrait, + ) -> Option<chalk_ir::TraitId<Interner>> { + let lang_attr = lang_attr_from_well_known_trait(well_known_trait); + let trait_ = match self.db.lang_item(self.krate, lang_attr.into()) { + Some(LangItemTarget::TraitId(trait_)) => trait_, + _ => return None, + }; + Some(to_chalk_trait_id(trait_)) + } + + fn program_clauses_for_env( + &self, + environment: &chalk_ir::Environment<Interner>, + ) -> chalk_ir::ProgramClauses<Interner> { + self.db.program_clauses_for_chalk_env(self.krate, environment.clone()) + } + + fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> { + let full_id = self.db.lookup_intern_impl_trait_id(id.into()); + let bound = match full_id { + crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => { + let datas = self + .db + .return_type_impl_traits(func) + .expect("impl trait id without impl traits"); + let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders(); + let data = &datas.impl_traits[idx as usize]; + let bound = OpaqueTyDatumBound { + bounds: make_single_type_binders(data.bounds.skip_binders().to_vec()), + where_clauses: chalk_ir::Binders::empty(Interner, vec![]), + }; + chalk_ir::Binders::new(binders, bound) + } + crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => { + if let Some((future_trait, future_output)) = self + .db + .lang_item(self.krate, SmolStr::new_inline("future_trait")) + .and_then(|item| item.as_trait()) + .and_then(|trait_| { + let alias = + self.db.trait_data(trait_).associated_type_by_name(&name![Output])?; + Some((trait_, alias)) + }) + { + // Making up Symbol’s value as variable is void: AsyncBlock<T>: + // + // |--------------------OpaqueTyDatum-------------------| + // |-------------OpaqueTyDatumBound--------------| + // for<T> <Self> [Future<Self>, Future::Output<Self> = T] + // ^1 ^0 ^0 ^0 ^1 + let impl_bound = WhereClause::Implemented(TraitRef { + trait_id: to_chalk_trait_id(future_trait), + // Self type as the first parameter. + substitution: Substitution::from1( + Interner, + TyKind::BoundVar(BoundVar { + debruijn: DebruijnIndex::INNERMOST, + index: 0, + }) + .intern(Interner), + ), + }); + let mut binder = vec![]; + binder.push(crate::wrap_empty_binders(impl_bound)); + let sized_trait = self + .db + .lang_item(self.krate, SmolStr::new_inline("sized")) + .and_then(|item| item.as_trait()); + if let Some(sized_trait_) = sized_trait { + let sized_bound = WhereClause::Implemented(TraitRef { + trait_id: to_chalk_trait_id(sized_trait_), + // Self type as the first parameter. + substitution: Substitution::from1( + Interner, + TyKind::BoundVar(BoundVar { + debruijn: DebruijnIndex::INNERMOST, + index: 0, + }) + .intern(Interner), + ), + }); + binder.push(crate::wrap_empty_binders(sized_bound)); + } + let proj_bound = WhereClause::AliasEq(AliasEq { + alias: AliasTy::Projection(ProjectionTy { + associated_ty_id: to_assoc_type_id(future_output), + // Self type as the first parameter. + substitution: Substitution::from1( + Interner, + TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)) + .intern(Interner), + ), + }), + // The parameter of the opaque type. + ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }) + .intern(Interner), + }); + binder.push(crate::wrap_empty_binders(proj_bound)); + let bound = OpaqueTyDatumBound { + bounds: make_single_type_binders(binder), + where_clauses: chalk_ir::Binders::empty(Interner, vec![]), + }; + // The opaque type has 1 parameter. + make_single_type_binders(bound) + } else { + // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback. + let bound = OpaqueTyDatumBound { + bounds: chalk_ir::Binders::empty(Interner, vec![]), + where_clauses: chalk_ir::Binders::empty(Interner, vec![]), + }; + // The opaque type has 1 parameter. + make_single_type_binders(bound) + } + } + }; + + Arc::new(OpaqueTyDatum { opaque_ty_id: id, bound }) + } + + fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> { + // FIXME: actually provide the hidden type; it is relevant for auto traits + TyKind::Error.intern(Interner) + } + + fn is_object_safe(&self, _trait_id: chalk_ir::TraitId<Interner>) -> bool { + // FIXME: implement actual object safety + true + } + + fn closure_kind( + &self, + _closure_id: chalk_ir::ClosureId<Interner>, + _substs: &chalk_ir::Substitution<Interner>, + ) -> rust_ir::ClosureKind { + // Fn is the closure kind that implements all three traits + rust_ir::ClosureKind::Fn + } + fn closure_inputs_and_output( + &self, + _closure_id: chalk_ir::ClosureId<Interner>, + substs: &chalk_ir::Substitution<Interner>, + ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> { + let sig_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone(); + let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr"); + let io = rust_ir::FnDefInputsAndOutputDatum { + argument_types: sig.params().to_vec(), + return_type: sig.ret().clone(), + }; + chalk_ir::Binders::empty(Interner, io.shifted_in(Interner)) + } + fn closure_upvars( + &self, + _closure_id: chalk_ir::ClosureId<Interner>, + _substs: &chalk_ir::Substitution<Interner>, + ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> { + let ty = TyBuilder::unit(); + chalk_ir::Binders::empty(Interner, ty) + } + fn closure_fn_substitution( + &self, + _closure_id: chalk_ir::ClosureId<Interner>, + _substs: &chalk_ir::Substitution<Interner>, + ) -> chalk_ir::Substitution<Interner> { + Substitution::empty(Interner) + } + + fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String { + let id = from_chalk_trait_id(trait_id); + self.db.trait_data(id).name.to_string() + } + fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String { + match adt_id { + hir_def::AdtId::StructId(id) => self.db.struct_data(id).name.to_string(), + hir_def::AdtId::EnumId(id) => self.db.enum_data(id).name.to_string(), + hir_def::AdtId::UnionId(id) => self.db.union_data(id).name.to_string(), + } + } + fn adt_size_align(&self, _id: chalk_ir::AdtId<Interner>) -> Arc<rust_ir::AdtSizeAlign> { + // FIXME + Arc::new(rust_ir::AdtSizeAlign::from_one_zst(false)) + } + fn assoc_type_name(&self, assoc_ty_id: chalk_ir::AssocTypeId<Interner>) -> String { + let id = self.db.associated_ty_data(assoc_ty_id).name; + self.db.type_alias_data(id).name.to_string() + } + fn opaque_type_name(&self, opaque_ty_id: chalk_ir::OpaqueTyId<Interner>) -> String { + format!("Opaque_{}", opaque_ty_id.0) + } + fn fn_def_name(&self, fn_def_id: chalk_ir::FnDefId<Interner>) -> String { + format!("fn_{}", fn_def_id.0) + } + fn generator_datum( + &self, + _: chalk_ir::GeneratorId<Interner>, + ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorDatum<Interner>> { + // FIXME + unimplemented!() + } + fn generator_witness_datum( + &self, + _: chalk_ir::GeneratorId<Interner>, + ) -> std::sync::Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<Interner>> { + // FIXME + unimplemented!() + } + + fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<Interner> { + &self.db + } +} + +impl<'a> chalk_ir::UnificationDatabase<Interner> for &'a dyn HirDatabase { + fn fn_def_variance( + &self, + fn_def_id: chalk_ir::FnDefId<Interner>, + ) -> chalk_ir::Variances<Interner> { + HirDatabase::fn_def_variance(*self, fn_def_id) + } + + fn adt_variance(&self, adt_id: chalk_ir::AdtId<Interner>) -> chalk_ir::Variances<Interner> { + HirDatabase::adt_variance(*self, adt_id) + } +} + +pub(crate) fn program_clauses_for_chalk_env_query( + db: &dyn HirDatabase, + krate: CrateId, + environment: chalk_ir::Environment<Interner>, +) -> chalk_ir::ProgramClauses<Interner> { + chalk_solve::program_clauses_for_env(&ChalkContext { db, krate }, &environment) +} + +pub(crate) fn associated_ty_data_query( + db: &dyn HirDatabase, + id: AssocTypeId, +) -> Arc<AssociatedTyDatum> { + debug!("associated_ty_data {:?}", id); + let type_alias: TypeAliasId = from_assoc_type_id(id); + let trait_ = match type_alias.lookup(db.upcast()).container { + ItemContainerId::TraitId(t) => t, + _ => panic!("associated type not in trait"), + }; + + // Lower bounds -- we could/should maybe move this to a separate query in `lower` + let type_alias_data = db.type_alias_data(type_alias); + let generic_params = generics(db.upcast(), type_alias.into()); + // let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST); + let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast()); + let ctx = crate::TyLoweringContext::new(db, &resolver) + .with_type_param_mode(crate::lower::ParamLoweringMode::Variable); + let pro_ty = TyBuilder::assoc_type_projection(db, type_alias) + .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0) + .build(); + let self_ty = TyKind::Alias(AliasTy::Projection(pro_ty)).intern(Interner); + let mut bounds: Vec<_> = type_alias_data + .bounds + .iter() + .flat_map(|bound| ctx.lower_type_bound(bound, self_ty.clone(), false)) + .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty)) + .collect(); + + if !ctx.unsized_types.borrow().contains(&self_ty) { + let sized_trait = db + .lang_item(resolver.krate(), SmolStr::new_inline("sized")) + .and_then(|lang_item| lang_item.as_trait().map(to_chalk_trait_id)); + let sized_bound = sized_trait.into_iter().map(|sized_trait| { + let trait_bound = + rust_ir::TraitBound { trait_id: sized_trait, args_no_self: Default::default() }; + let inline_bound = rust_ir::InlineBound::TraitBound(trait_bound); + chalk_ir::Binders::empty(Interner, inline_bound) + }); + bounds.extend(sized_bound); + bounds.shrink_to_fit(); + } + + // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed. + // (rust-analyzer#9052) + // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars); + let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] }; + let datum = AssociatedTyDatum { + trait_id: to_chalk_trait_id(trait_), + id, + name: type_alias, + binders: make_binders(db, &generic_params, bound_data), + }; + Arc::new(datum) +} + +pub(crate) fn trait_datum_query( + db: &dyn HirDatabase, + krate: CrateId, + trait_id: TraitId, +) -> Arc<TraitDatum> { + debug!("trait_datum {:?}", trait_id); + let trait_ = from_chalk_trait_id(trait_id); + let trait_data = db.trait_data(trait_); + debug!("trait {:?} = {:?}", trait_id, trait_data.name); + let generic_params = generics(db.upcast(), trait_.into()); + let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST); + let flags = rust_ir::TraitFlags { + auto: trait_data.is_auto, + upstream: trait_.lookup(db.upcast()).container.krate() != krate, + non_enumerable: true, + coinductive: false, // only relevant for Chalk testing + // FIXME: set these flags correctly + marker: false, + fundamental: false, + }; + let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars); + let associated_ty_ids = trait_data.associated_types().map(to_assoc_type_id).collect(); + let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses }; + let well_known = + lang_attr(db.upcast(), trait_).and_then(|name| well_known_trait_from_lang_attr(&name)); + let trait_datum = TraitDatum { + id: trait_id, + binders: make_binders(db, &generic_params, trait_datum_bound), + flags, + associated_ty_ids, + well_known, + }; + Arc::new(trait_datum) +} + +fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> { + Some(match name { + "clone" => WellKnownTrait::Clone, + "coerce_unsized" => WellKnownTrait::CoerceUnsized, + "copy" => WellKnownTrait::Copy, + "discriminant_kind" => WellKnownTrait::DiscriminantKind, + "dispatch_from_dyn" => WellKnownTrait::DispatchFromDyn, + "drop" => WellKnownTrait::Drop, + "fn" => WellKnownTrait::Fn, + "fn_mut" => WellKnownTrait::FnMut, + "fn_once" => WellKnownTrait::FnOnce, + "generator" => WellKnownTrait::Generator, + "sized" => WellKnownTrait::Sized, + "unpin" => WellKnownTrait::Unpin, + "unsize" => WellKnownTrait::Unsize, + _ => return None, + }) +} + +fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str { + match attr { + WellKnownTrait::Clone => "clone", + WellKnownTrait::CoerceUnsized => "coerce_unsized", + WellKnownTrait::Copy => "copy", + WellKnownTrait::DiscriminantKind => "discriminant_kind", + WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn", + WellKnownTrait::Drop => "drop", + WellKnownTrait::Fn => "fn", + WellKnownTrait::FnMut => "fn_mut", + WellKnownTrait::FnOnce => "fn_once", + WellKnownTrait::Generator => "generator", + WellKnownTrait::Sized => "sized", + WellKnownTrait::Unpin => "unpin", + WellKnownTrait::Unsize => "unsize", + } +} + +pub(crate) fn struct_datum_query( + db: &dyn HirDatabase, + krate: CrateId, + struct_id: AdtId, +) -> Arc<StructDatum> { + debug!("struct_datum {:?}", struct_id); + let chalk_ir::AdtId(adt_id) = struct_id; + let generic_params = generics(db.upcast(), adt_id.into()); + let upstream = adt_id.module(db.upcast()).krate() != krate; + let where_clauses = { + let generic_params = generics(db.upcast(), adt_id.into()); + let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST); + convert_where_clauses(db, adt_id.into(), &bound_vars) + }; + let flags = rust_ir::AdtFlags { + upstream, + // FIXME set fundamental and phantom_data flags correctly + fundamental: false, + phantom_data: false, + }; + // FIXME provide enum variants properly (for auto traits) + let variant = rust_ir::AdtVariantDatum { + fields: Vec::new(), // FIXME add fields (only relevant for auto traits), + }; + let struct_datum_bound = rust_ir::AdtDatumBound { variants: vec![variant], where_clauses }; + let struct_datum = StructDatum { + // FIXME set ADT kind + kind: rust_ir::AdtKind::Struct, + id: struct_id, + binders: make_binders(db, &generic_params, struct_datum_bound), + flags, + }; + Arc::new(struct_datum) +} + +pub(crate) fn impl_datum_query( + db: &dyn HirDatabase, + krate: CrateId, + impl_id: ImplId, +) -> Arc<ImplDatum> { + let _p = profile::span("impl_datum"); + debug!("impl_datum {:?}", impl_id); + let impl_: hir_def::ImplId = from_chalk(db, impl_id); + impl_def_datum(db, krate, impl_id, impl_) +} + +fn impl_def_datum( + db: &dyn HirDatabase, + krate: CrateId, + chalk_id: ImplId, + impl_id: hir_def::ImplId, +) -> Arc<ImplDatum> { + let trait_ref = db + .impl_trait(impl_id) + // ImplIds for impls where the trait ref can't be resolved should never reach Chalk + .expect("invalid impl passed to Chalk") + .into_value_and_skipped_binders() + .0; + let impl_data = db.impl_data(impl_id); + + let generic_params = generics(db.upcast(), impl_id.into()); + let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST); + let trait_ = trait_ref.hir_trait_id(); + let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate { + rust_ir::ImplType::Local + } else { + rust_ir::ImplType::External + }; + let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars); + let negative = impl_data.is_negative; + debug!( + "impl {:?}: {}{} where {:?}", + chalk_id, + if negative { "!" } else { "" }, + trait_ref.display(db), + where_clauses + ); + + let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive }; + + let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses }; + let trait_data = db.trait_data(trait_); + let associated_ty_value_ids = impl_data + .items + .iter() + .filter_map(|item| match item { + AssocItemId::TypeAliasId(type_alias) => Some(*type_alias), + _ => None, + }) + .filter(|&type_alias| { + // don't include associated types that don't exist in the trait + let name = &db.type_alias_data(type_alias).name; + trait_data.associated_type_by_name(name).is_some() + }) + .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db)) + .collect(); + debug!("impl_datum: {:?}", impl_datum_bound); + let impl_datum = ImplDatum { + binders: make_binders(db, &generic_params, impl_datum_bound), + impl_type, + polarity, + associated_ty_value_ids, + }; + Arc::new(impl_datum) +} + +pub(crate) fn associated_ty_value_query( + db: &dyn HirDatabase, + krate: CrateId, + id: AssociatedTyValueId, +) -> Arc<AssociatedTyValue> { + let type_alias: TypeAliasAsValue = from_chalk(db, id); + type_alias_associated_ty_value(db, krate, type_alias.0) +} + +fn type_alias_associated_ty_value( + db: &dyn HirDatabase, + _krate: CrateId, + type_alias: TypeAliasId, +) -> Arc<AssociatedTyValue> { + let type_alias_data = db.type_alias_data(type_alias); + let impl_id = match type_alias.lookup(db.upcast()).container { + ItemContainerId::ImplId(it) => it, + _ => panic!("assoc ty value should be in impl"), + }; + + let trait_ref = db + .impl_trait(impl_id) + .expect("assoc ty value should not exist") + .into_value_and_skipped_binders() + .0; // we don't return any assoc ty values if the impl'd trait can't be resolved + + let assoc_ty = db + .trait_data(trait_ref.hir_trait_id()) + .associated_type_by_name(&type_alias_data.name) + .expect("assoc ty value should not exist"); // validated when building the impl data as well + let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders(); + let value_bound = rust_ir::AssociatedTyValueBound { ty }; + let value = rust_ir::AssociatedTyValue { + impl_id: impl_id.to_chalk(db), + associated_ty_id: to_assoc_type_id(assoc_ty), + value: chalk_ir::Binders::new(binders, value_bound), + }; + Arc::new(value) +} + +pub(crate) fn fn_def_datum_query( + db: &dyn HirDatabase, + _krate: CrateId, + fn_def_id: FnDefId, +) -> Arc<FnDefDatum> { + let callable_def: CallableDefId = from_chalk(db, fn_def_id); + let generic_params = generics(db.upcast(), callable_def.into()); + let (sig, binders) = db.callable_item_signature(callable_def).into_value_and_skipped_binders(); + let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST); + let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars); + let bound = rust_ir::FnDefDatumBound { + // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway + inputs_and_output: chalk_ir::Binders::empty( + Interner, + rust_ir::FnDefInputsAndOutputDatum { + argument_types: sig.params().to_vec(), + return_type: sig.ret().clone(), + } + .shifted_in(Interner), + ), + where_clauses, + }; + let datum = FnDefDatum { + id: fn_def_id, + sig: chalk_ir::FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: sig.is_varargs }, + binders: chalk_ir::Binders::new(binders, bound), + }; + Arc::new(datum) +} + +pub(crate) fn fn_def_variance_query(db: &dyn HirDatabase, fn_def_id: FnDefId) -> Variances { + let callable_def: CallableDefId = from_chalk(db, fn_def_id); + let generic_params = generics(db.upcast(), callable_def.into()); + Variances::from_iter( + Interner, + std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()), + ) +} + +pub(crate) fn adt_variance_query( + db: &dyn HirDatabase, + chalk_ir::AdtId(adt_id): AdtId, +) -> Variances { + let generic_params = generics(db.upcast(), adt_id.into()); + Variances::from_iter( + Interner, + std::iter::repeat(chalk_ir::Variance::Invariant).take(generic_params.len()), + ) +} + +pub(super) fn convert_where_clauses( + db: &dyn HirDatabase, + def: GenericDefId, + substs: &Substitution, +) -> Vec<chalk_ir::QuantifiedWhereClause<Interner>> { + let generic_predicates = db.generic_predicates(def); + let mut result = Vec::with_capacity(generic_predicates.len()); + for pred in generic_predicates.iter() { + result.push(pred.clone().substitute(Interner, substs)); + } + result +} + +pub(super) fn generic_predicate_to_inline_bound( + db: &dyn HirDatabase, + pred: &QuantifiedWhereClause, + self_ty: &Ty, +) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> { + // An InlineBound is like a GenericPredicate, except the self type is left out. + // We don't have a special type for this, but Chalk does. + let self_ty_shifted_in = self_ty.clone().shifted_in_from(Interner, DebruijnIndex::ONE); + let (pred, binders) = pred.as_ref().into_value_and_skipped_binders(); + match pred { + WhereClause::Implemented(trait_ref) => { + if trait_ref.self_type_parameter(Interner) != self_ty_shifted_in { + // we can only convert predicates back to type bounds if they + // have the expected self type + return None; + } + let args_no_self = trait_ref.substitution.as_slice(Interner)[1..] + .iter() + .map(|ty| ty.clone().cast(Interner)) + .collect(); + let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self }; + Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound))) + } + WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => { + if projection_ty.self_type_parameter(Interner) != self_ty_shifted_in { + return None; + } + let trait_ = projection_ty.trait_(db); + let args_no_self = projection_ty.substitution.as_slice(Interner)[1..] + .iter() + .map(|ty| ty.clone().cast(Interner)) + .collect(); + let alias_eq_bound = rust_ir::AliasEqBound { + value: ty.clone(), + trait_bound: rust_ir::TraitBound { + trait_id: to_chalk_trait_id(trait_), + args_no_self, + }, + associated_ty_id: projection_ty.associated_ty_id, + parameters: Vec::new(), // FIXME we don't support generic associated types yet + }; + Some(chalk_ir::Binders::new( + binders, + rust_ir::InlineBound::AliasEqBound(alias_eq_bound), + )) + } + _ => None, + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs new file mode 100644 index 000000000..a9c124b42 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs @@ -0,0 +1,358 @@ +//! Various extensions traits for Chalk types. + +use chalk_ir::{FloatTy, IntTy, Mutability, Scalar, UintTy}; +use hir_def::{ + builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType, BuiltinUint}, + generics::TypeOrConstParamData, + type_ref::Rawness, + FunctionId, GenericDefId, HasModule, ItemContainerId, Lookup, TraitId, +}; +use syntax::SmolStr; + +use crate::{ + db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, + from_placeholder_idx, to_chalk_trait_id, AdtId, AliasEq, AliasTy, Binders, CallableDefId, + CallableSig, FnPointer, ImplTraitId, Interner, Lifetime, ProjectionTy, QuantifiedWhereClause, + Substitution, TraitRef, Ty, TyBuilder, TyKind, WhereClause, +}; + +pub trait TyExt { + fn is_unit(&self) -> bool; + fn is_never(&self) -> bool; + fn is_unknown(&self) -> bool; + fn is_ty_var(&self) -> bool; + + fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)>; + fn as_builtin(&self) -> Option<BuiltinType>; + fn as_tuple(&self) -> Option<&Substitution>; + fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId>; + fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)>; + fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)>; + fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId>; + + fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId>; + fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig>; + + fn strip_references(&self) -> &Ty; + fn strip_reference(&self) -> &Ty; + + /// If this is a `dyn Trait`, returns that trait. + fn dyn_trait(&self) -> Option<TraitId>; + + fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>>; + fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId>; + + /// FIXME: Get rid of this, it's not a good abstraction + fn equals_ctor(&self, other: &Ty) -> bool; +} + +impl TyExt for Ty { + fn is_unit(&self) -> bool { + matches!(self.kind(Interner), TyKind::Tuple(0, _)) + } + + fn is_never(&self) -> bool { + matches!(self.kind(Interner), TyKind::Never) + } + + fn is_unknown(&self) -> bool { + matches!(self.kind(Interner), TyKind::Error) + } + + fn is_ty_var(&self) -> bool { + matches!(self.kind(Interner), TyKind::InferenceVar(_, _)) + } + + fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> { + match self.kind(Interner) { + TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)), + _ => None, + } + } + + fn as_builtin(&self) -> Option<BuiltinType> { + match self.kind(Interner) { + TyKind::Str => Some(BuiltinType::Str), + TyKind::Scalar(Scalar::Bool) => Some(BuiltinType::Bool), + TyKind::Scalar(Scalar::Char) => Some(BuiltinType::Char), + TyKind::Scalar(Scalar::Float(fty)) => Some(BuiltinType::Float(match fty { + FloatTy::F64 => BuiltinFloat::F64, + FloatTy::F32 => BuiltinFloat::F32, + })), + TyKind::Scalar(Scalar::Int(ity)) => Some(BuiltinType::Int(match ity { + IntTy::Isize => BuiltinInt::Isize, + IntTy::I8 => BuiltinInt::I8, + IntTy::I16 => BuiltinInt::I16, + IntTy::I32 => BuiltinInt::I32, + IntTy::I64 => BuiltinInt::I64, + IntTy::I128 => BuiltinInt::I128, + })), + TyKind::Scalar(Scalar::Uint(ity)) => Some(BuiltinType::Uint(match ity { + UintTy::Usize => BuiltinUint::Usize, + UintTy::U8 => BuiltinUint::U8, + UintTy::U16 => BuiltinUint::U16, + UintTy::U32 => BuiltinUint::U32, + UintTy::U64 => BuiltinUint::U64, + UintTy::U128 => BuiltinUint::U128, + })), + _ => None, + } + } + + fn as_tuple(&self) -> Option<&Substitution> { + match self.kind(Interner) { + TyKind::Tuple(_, substs) => Some(substs), + _ => None, + } + } + + fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId> { + match self.callable_def(db) { + Some(CallableDefId::FunctionId(func)) => Some(func), + Some(CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_)) | None => None, + } + } + fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)> { + match self.kind(Interner) { + TyKind::Ref(mutability, lifetime, ty) => Some((ty, lifetime.clone(), *mutability)), + _ => None, + } + } + + fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> { + match self.kind(Interner) { + TyKind::Ref(mutability, _, ty) => Some((ty, Rawness::Ref, *mutability)), + TyKind::Raw(mutability, ty) => Some((ty, Rawness::RawPtr, *mutability)), + _ => None, + } + } + + fn as_generic_def(&self, db: &dyn HirDatabase) -> Option<GenericDefId> { + match *self.kind(Interner) { + TyKind::Adt(AdtId(adt), ..) => Some(adt.into()), + TyKind::FnDef(callable, ..) => { + Some(db.lookup_intern_callable_def(callable.into()).into()) + } + TyKind::AssociatedType(type_alias, ..) => Some(from_assoc_type_id(type_alias).into()), + TyKind::Foreign(type_alias, ..) => Some(from_foreign_def_id(type_alias).into()), + _ => None, + } + } + + fn callable_def(&self, db: &dyn HirDatabase) -> Option<CallableDefId> { + match self.kind(Interner) { + &TyKind::FnDef(def, ..) => Some(db.lookup_intern_callable_def(def.into())), + _ => None, + } + } + + fn callable_sig(&self, db: &dyn HirDatabase) -> Option<CallableSig> { + match self.kind(Interner) { + TyKind::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)), + TyKind::FnDef(def, parameters) => { + let callable_def = db.lookup_intern_callable_def((*def).into()); + let sig = db.callable_item_signature(callable_def); + Some(sig.substitute(Interner, ¶meters)) + } + TyKind::Closure(.., substs) => { + let sig_param = substs.at(Interner, 0).assert_ty_ref(Interner); + sig_param.callable_sig(db) + } + _ => None, + } + } + + fn dyn_trait(&self) -> Option<TraitId> { + let trait_ref = match self.kind(Interner) { + TyKind::Dyn(dyn_ty) => dyn_ty.bounds.skip_binders().interned().get(0).and_then(|b| { + match b.skip_binders() { + WhereClause::Implemented(trait_ref) => Some(trait_ref), + _ => None, + } + }), + _ => None, + }?; + Some(from_chalk_trait_id(trait_ref.trait_id)) + } + + fn strip_references(&self) -> &Ty { + let mut t: &Ty = self; + while let TyKind::Ref(_mutability, _lifetime, ty) = t.kind(Interner) { + t = ty; + } + t + } + + fn strip_reference(&self) -> &Ty { + self.as_reference().map_or(self, |(ty, _, _)| ty) + } + + fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>> { + match self.kind(Interner) { + TyKind::OpaqueType(opaque_ty_id, subst) => { + match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) { + ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => { + let krate = def.module(db.upcast()).krate(); + if let Some(future_trait) = db + .lang_item(krate, SmolStr::new_inline("future_trait")) + .and_then(|item| item.as_trait()) + { + // This is only used by type walking. + // Parameters will be walked outside, and projection predicate is not used. + // So just provide the Future trait. + let impl_bound = Binders::empty( + Interner, + WhereClause::Implemented(TraitRef { + trait_id: to_chalk_trait_id(future_trait), + substitution: Substitution::empty(Interner), + }), + ); + Some(vec![impl_bound]) + } else { + None + } + } + ImplTraitId::ReturnTypeImplTrait(func, idx) => { + db.return_type_impl_traits(func).map(|it| { + let data = (*it) + .as_ref() + .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); + data.substitute(Interner, &subst).into_value_and_skipped_binders().0 + }) + } + } + } + TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { + let predicates = match db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into()) + { + ImplTraitId::ReturnTypeImplTrait(func, idx) => { + db.return_type_impl_traits(func).map(|it| { + let data = (*it) + .as_ref() + .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); + data.substitute(Interner, &opaque_ty.substitution) + }) + } + // It always has an parameter for Future::Output type. + ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(), + }; + + predicates.map(|it| it.into_value_and_skipped_binders().0) + } + TyKind::Placeholder(idx) => { + let id = from_placeholder_idx(db, *idx); + let generic_params = db.generic_params(id.parent); + let param_data = &generic_params.type_or_consts[id.local_id]; + match param_data { + TypeOrConstParamData::TypeParamData(p) => match p.provenance { + hir_def::generics::TypeParamProvenance::ArgumentImplTrait => { + let substs = TyBuilder::placeholder_subst(db, id.parent); + let predicates = db + .generic_predicates(id.parent) + .iter() + .map(|pred| pred.clone().substitute(Interner, &substs)) + .filter(|wc| match &wc.skip_binders() { + WhereClause::Implemented(tr) => { + &tr.self_type_parameter(Interner) == self + } + WhereClause::AliasEq(AliasEq { + alias: AliasTy::Projection(proj), + ty: _, + }) => &proj.self_type_parameter(Interner) == self, + _ => false, + }) + .collect::<Vec<_>>(); + + Some(predicates) + } + _ => None, + }, + _ => None, + } + } + _ => None, + } + } + + fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> { + match self.kind(Interner) { + TyKind::AssociatedType(id, ..) => { + match from_assoc_type_id(*id).lookup(db.upcast()).container { + ItemContainerId::TraitId(trait_id) => Some(trait_id), + _ => None, + } + } + TyKind::Alias(AliasTy::Projection(projection_ty)) => { + match from_assoc_type_id(projection_ty.associated_ty_id) + .lookup(db.upcast()) + .container + { + ItemContainerId::TraitId(trait_id) => Some(trait_id), + _ => None, + } + } + _ => None, + } + } + + fn equals_ctor(&self, other: &Ty) -> bool { + match (self.kind(Interner), other.kind(Interner)) { + (TyKind::Adt(adt, ..), TyKind::Adt(adt2, ..)) => adt == adt2, + (TyKind::Slice(_), TyKind::Slice(_)) | (TyKind::Array(_, _), TyKind::Array(_, _)) => { + true + } + (TyKind::FnDef(def_id, ..), TyKind::FnDef(def_id2, ..)) => def_id == def_id2, + (TyKind::OpaqueType(ty_id, ..), TyKind::OpaqueType(ty_id2, ..)) => ty_id == ty_id2, + (TyKind::AssociatedType(ty_id, ..), TyKind::AssociatedType(ty_id2, ..)) => { + ty_id == ty_id2 + } + (TyKind::Foreign(ty_id, ..), TyKind::Foreign(ty_id2, ..)) => ty_id == ty_id2, + (TyKind::Closure(id1, _), TyKind::Closure(id2, _)) => id1 == id2, + (TyKind::Ref(mutability, ..), TyKind::Ref(mutability2, ..)) + | (TyKind::Raw(mutability, ..), TyKind::Raw(mutability2, ..)) => { + mutability == mutability2 + } + ( + TyKind::Function(FnPointer { num_binders, sig, .. }), + TyKind::Function(FnPointer { num_binders: num_binders2, sig: sig2, .. }), + ) => num_binders == num_binders2 && sig == sig2, + (TyKind::Tuple(cardinality, _), TyKind::Tuple(cardinality2, _)) => { + cardinality == cardinality2 + } + (TyKind::Str, TyKind::Str) | (TyKind::Never, TyKind::Never) => true, + (TyKind::Scalar(scalar), TyKind::Scalar(scalar2)) => scalar == scalar2, + _ => false, + } + } +} + +pub trait ProjectionTyExt { + fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef; + fn trait_(&self, db: &dyn HirDatabase) -> TraitId; +} + +impl ProjectionTyExt for ProjectionTy { + fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef { + TraitRef { + trait_id: to_chalk_trait_id(self.trait_(db)), + substitution: self.substitution.clone(), + } + } + + fn trait_(&self, db: &dyn HirDatabase) -> TraitId { + match from_assoc_type_id(self.associated_ty_id).lookup(db.upcast()).container { + ItemContainerId::TraitId(it) => it, + _ => panic!("projection ty without parent trait"), + } + } +} + +pub trait TraitRefExt { + fn hir_trait_id(&self) -> TraitId; +} + +impl TraitRefExt for TraitRef { + fn hir_trait_id(&self) -> TraitId { + from_chalk_trait_id(self.trait_id) + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs new file mode 100644 index 000000000..0495a4e64 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs @@ -0,0 +1,469 @@ +//! Constant evaluation details + +use std::{ + collections::HashMap, + convert::TryInto, + fmt::{Display, Write}, +}; + +use chalk_ir::{BoundVar, DebruijnIndex, GenericArgData, IntTy, Scalar}; +use hir_def::{ + expr::{ArithOp, BinaryOp, Expr, ExprId, Literal, Pat, PatId}, + path::ModPath, + resolver::{resolver_for_expr, ResolveValueResult, Resolver, ValueNs}, + type_ref::ConstScalar, + ConstId, DefWithBodyId, +}; +use la_arena::{Arena, Idx}; +use stdx::never; + +use crate::{ + db::HirDatabase, infer::InferenceContext, lower::ParamLoweringMode, to_placeholder_idx, + utils::Generics, Const, ConstData, ConstValue, GenericArg, InferenceResult, Interner, Ty, + TyBuilder, TyKind, +}; + +/// Extension trait for [`Const`] +pub trait ConstExt { + /// Is a [`Const`] unknown? + fn is_unknown(&self) -> bool; +} + +impl ConstExt for Const { + fn is_unknown(&self) -> bool { + match self.data(Interner).value { + // interned Unknown + chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { + interned: ConstScalar::Unknown, + }) => true, + + // interned concrete anything else + chalk_ir::ConstValue::Concrete(..) => false, + + _ => { + tracing::error!( + "is_unknown was called on a non-concrete constant value! {:?}", + self + ); + true + } + } + } +} + +pub struct ConstEvalCtx<'a> { + pub db: &'a dyn HirDatabase, + pub owner: DefWithBodyId, + pub exprs: &'a Arena<Expr>, + pub pats: &'a Arena<Pat>, + pub local_data: HashMap<PatId, ComputedExpr>, + infer: &'a InferenceResult, +} + +impl ConstEvalCtx<'_> { + fn expr_ty(&mut self, expr: ExprId) -> Ty { + self.infer[expr].clone() + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ConstEvalError { + NotSupported(&'static str), + SemanticError(&'static str), + Loop, + IncompleteExpr, + Panic(String), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ComputedExpr { + Literal(Literal), + Tuple(Box<[ComputedExpr]>), +} + +impl Display for ComputedExpr { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ComputedExpr::Literal(l) => match l { + Literal::Int(x, _) => { + if *x >= 10 { + write!(f, "{} ({:#X})", x, x) + } else { + x.fmt(f) + } + } + Literal::Uint(x, _) => { + if *x >= 10 { + write!(f, "{} ({:#X})", x, x) + } else { + x.fmt(f) + } + } + Literal::Float(x, _) => x.fmt(f), + Literal::Bool(x) => x.fmt(f), + Literal::Char(x) => std::fmt::Debug::fmt(x, f), + Literal::String(x) => std::fmt::Debug::fmt(x, f), + Literal::ByteString(x) => std::fmt::Debug::fmt(x, f), + }, + ComputedExpr::Tuple(t) => { + f.write_char('(')?; + for x in &**t { + x.fmt(f)?; + f.write_str(", ")?; + } + f.write_char(')') + } + } + } +} + +fn scalar_max(scalar: &Scalar) -> i128 { + match scalar { + Scalar::Bool => 1, + Scalar::Char => u32::MAX as i128, + Scalar::Int(x) => match x { + IntTy::Isize => isize::MAX as i128, + IntTy::I8 => i8::MAX as i128, + IntTy::I16 => i16::MAX as i128, + IntTy::I32 => i32::MAX as i128, + IntTy::I64 => i64::MAX as i128, + IntTy::I128 => i128::MAX as i128, + }, + Scalar::Uint(x) => match x { + chalk_ir::UintTy::Usize => usize::MAX as i128, + chalk_ir::UintTy::U8 => u8::MAX as i128, + chalk_ir::UintTy::U16 => u16::MAX as i128, + chalk_ir::UintTy::U32 => u32::MAX as i128, + chalk_ir::UintTy::U64 => u64::MAX as i128, + chalk_ir::UintTy::U128 => i128::MAX as i128, // ignore too big u128 for now + }, + Scalar::Float(_) => 0, + } +} + +fn is_valid(scalar: &Scalar, value: i128) -> bool { + if value < 0 { + !matches!(scalar, Scalar::Uint(_)) && -scalar_max(scalar) - 1 <= value + } else { + value <= scalar_max(scalar) + } +} + +pub fn eval_const( + expr_id: ExprId, + ctx: &mut ConstEvalCtx<'_>, +) -> Result<ComputedExpr, ConstEvalError> { + let expr = &ctx.exprs[expr_id]; + match expr { + Expr::Missing => Err(ConstEvalError::IncompleteExpr), + Expr::Literal(l) => Ok(ComputedExpr::Literal(l.clone())), + &Expr::UnaryOp { expr, op } => { + let ty = &ctx.expr_ty(expr); + let ev = eval_const(expr, ctx)?; + match op { + hir_def::expr::UnaryOp::Deref => Err(ConstEvalError::NotSupported("deref")), + hir_def::expr::UnaryOp::Not => { + let v = match ev { + ComputedExpr::Literal(Literal::Bool(b)) => { + return Ok(ComputedExpr::Literal(Literal::Bool(!b))) + } + ComputedExpr::Literal(Literal::Int(v, _)) => v, + ComputedExpr::Literal(Literal::Uint(v, _)) => v + .try_into() + .map_err(|_| ConstEvalError::NotSupported("too big u128"))?, + _ => return Err(ConstEvalError::NotSupported("this kind of operator")), + }; + let r = match ty.kind(Interner) { + TyKind::Scalar(Scalar::Uint(x)) => match x { + chalk_ir::UintTy::U8 => !(v as u8) as i128, + chalk_ir::UintTy::U16 => !(v as u16) as i128, + chalk_ir::UintTy::U32 => !(v as u32) as i128, + chalk_ir::UintTy::U64 => !(v as u64) as i128, + chalk_ir::UintTy::U128 => { + return Err(ConstEvalError::NotSupported("negation of u128")) + } + chalk_ir::UintTy::Usize => !(v as usize) as i128, + }, + TyKind::Scalar(Scalar::Int(x)) => match x { + chalk_ir::IntTy::I8 => !(v as i8) as i128, + chalk_ir::IntTy::I16 => !(v as i16) as i128, + chalk_ir::IntTy::I32 => !(v as i32) as i128, + chalk_ir::IntTy::I64 => !(v as i64) as i128, + chalk_ir::IntTy::I128 => !v, + chalk_ir::IntTy::Isize => !(v as isize) as i128, + }, + _ => return Err(ConstEvalError::NotSupported("unreachable?")), + }; + Ok(ComputedExpr::Literal(Literal::Int(r, None))) + } + hir_def::expr::UnaryOp::Neg => { + let v = match ev { + ComputedExpr::Literal(Literal::Int(v, _)) => v, + ComputedExpr::Literal(Literal::Uint(v, _)) => v + .try_into() + .map_err(|_| ConstEvalError::NotSupported("too big u128"))?, + _ => return Err(ConstEvalError::NotSupported("this kind of operator")), + }; + Ok(ComputedExpr::Literal(Literal::Int( + v.checked_neg().ok_or_else(|| { + ConstEvalError::Panic("overflow in negation".to_string()) + })?, + None, + ))) + } + } + } + &Expr::BinaryOp { lhs, rhs, op } => { + let ty = &ctx.expr_ty(lhs); + let lhs = eval_const(lhs, ctx)?; + let rhs = eval_const(rhs, ctx)?; + let op = op.ok_or(ConstEvalError::IncompleteExpr)?; + let v1 = match lhs { + ComputedExpr::Literal(Literal::Int(v, _)) => v, + ComputedExpr::Literal(Literal::Uint(v, _)) => { + v.try_into().map_err(|_| ConstEvalError::NotSupported("too big u128"))? + } + _ => return Err(ConstEvalError::NotSupported("this kind of operator")), + }; + let v2 = match rhs { + ComputedExpr::Literal(Literal::Int(v, _)) => v, + ComputedExpr::Literal(Literal::Uint(v, _)) => { + v.try_into().map_err(|_| ConstEvalError::NotSupported("too big u128"))? + } + _ => return Err(ConstEvalError::NotSupported("this kind of operator")), + }; + match op { + BinaryOp::ArithOp(b) => { + let panic_arith = ConstEvalError::Panic( + "attempt to run invalid arithmetic operation".to_string(), + ); + let r = match b { + ArithOp::Add => v1.checked_add(v2).ok_or_else(|| panic_arith.clone())?, + ArithOp::Mul => v1.checked_mul(v2).ok_or_else(|| panic_arith.clone())?, + ArithOp::Sub => v1.checked_sub(v2).ok_or_else(|| panic_arith.clone())?, + ArithOp::Div => v1.checked_div(v2).ok_or_else(|| panic_arith.clone())?, + ArithOp::Rem => v1.checked_rem(v2).ok_or_else(|| panic_arith.clone())?, + ArithOp::Shl => v1 + .checked_shl(v2.try_into().map_err(|_| panic_arith.clone())?) + .ok_or_else(|| panic_arith.clone())?, + ArithOp::Shr => v1 + .checked_shr(v2.try_into().map_err(|_| panic_arith.clone())?) + .ok_or_else(|| panic_arith.clone())?, + ArithOp::BitXor => v1 ^ v2, + ArithOp::BitOr => v1 | v2, + ArithOp::BitAnd => v1 & v2, + }; + if let TyKind::Scalar(s) = ty.kind(Interner) { + if !is_valid(s, r) { + return Err(panic_arith); + } + } + Ok(ComputedExpr::Literal(Literal::Int(r, None))) + } + BinaryOp::LogicOp(_) => Err(ConstEvalError::SemanticError("logic op on numbers")), + _ => Err(ConstEvalError::NotSupported("bin op on this operators")), + } + } + Expr::Block { statements, tail, .. } => { + let mut prev_values = HashMap::<PatId, Option<ComputedExpr>>::default(); + for statement in &**statements { + match *statement { + hir_def::expr::Statement::Let { pat: pat_id, initializer, .. } => { + let pat = &ctx.pats[pat_id]; + match pat { + Pat::Bind { subpat, .. } if subpat.is_none() => (), + _ => { + return Err(ConstEvalError::NotSupported("complex patterns in let")) + } + }; + let value = match initializer { + Some(x) => eval_const(x, ctx)?, + None => continue, + }; + if !prev_values.contains_key(&pat_id) { + let prev = ctx.local_data.insert(pat_id, value); + prev_values.insert(pat_id, prev); + } else { + ctx.local_data.insert(pat_id, value); + } + } + hir_def::expr::Statement::Expr { .. } => { + return Err(ConstEvalError::NotSupported("this kind of statement")) + } + } + } + let r = match tail { + &Some(x) => eval_const(x, ctx), + None => Ok(ComputedExpr::Tuple(Box::new([]))), + }; + // clean up local data, so caller will receive the exact map that passed to us + for (name, val) in prev_values { + match val { + Some(x) => ctx.local_data.insert(name, x), + None => ctx.local_data.remove(&name), + }; + } + r + } + Expr::Path(p) => { + let resolver = resolver_for_expr(ctx.db.upcast(), ctx.owner, expr_id); + let pr = resolver + .resolve_path_in_value_ns(ctx.db.upcast(), p.mod_path()) + .ok_or(ConstEvalError::SemanticError("unresolved path"))?; + let pr = match pr { + ResolveValueResult::ValueNs(v) => v, + ResolveValueResult::Partial(..) => { + return match ctx + .infer + .assoc_resolutions_for_expr(expr_id) + .ok_or(ConstEvalError::SemanticError("unresolved assoc item"))? + { + hir_def::AssocItemId::FunctionId(_) => { + Err(ConstEvalError::NotSupported("assoc function")) + } + hir_def::AssocItemId::ConstId(c) => ctx.db.const_eval(c), + hir_def::AssocItemId::TypeAliasId(_) => { + Err(ConstEvalError::NotSupported("assoc type alias")) + } + } + } + }; + match pr { + ValueNs::LocalBinding(pat_id) => { + let r = ctx + .local_data + .get(&pat_id) + .ok_or(ConstEvalError::NotSupported("Unexpected missing local"))?; + Ok(r.clone()) + } + ValueNs::ConstId(id) => ctx.db.const_eval(id), + ValueNs::GenericParam(_) => { + Err(ConstEvalError::NotSupported("const generic without substitution")) + } + _ => Err(ConstEvalError::NotSupported("path that are not const or local")), + } + } + _ => Err(ConstEvalError::NotSupported("This kind of expression")), + } +} + +pub(crate) fn path_to_const( + db: &dyn HirDatabase, + resolver: &Resolver, + path: &ModPath, + mode: ParamLoweringMode, + args_lazy: impl FnOnce() -> Generics, + debruijn: DebruijnIndex, +) -> Option<Const> { + match resolver.resolve_path_in_value_ns_fully(db.upcast(), &path) { + Some(ValueNs::GenericParam(p)) => { + let ty = db.const_param_ty(p); + let args = args_lazy(); + let value = match mode { + ParamLoweringMode::Placeholder => { + ConstValue::Placeholder(to_placeholder_idx(db, p.into())) + } + ParamLoweringMode::Variable => match args.param_idx(p.into()) { + Some(x) => ConstValue::BoundVar(BoundVar::new(debruijn, x)), + None => { + never!( + "Generic list doesn't contain this param: {:?}, {}, {:?}", + args, + path, + p + ); + return None; + } + }, + }; + Some(ConstData { ty, value }.intern(Interner)) + } + _ => None, + } +} + +pub fn unknown_const(ty: Ty) -> Const { + ConstData { + ty, + value: ConstValue::Concrete(chalk_ir::ConcreteConst { interned: ConstScalar::Unknown }), + } + .intern(Interner) +} + +pub fn unknown_const_as_generic(ty: Ty) -> GenericArg { + GenericArgData::Const(unknown_const(ty)).intern(Interner) +} + +/// Interns a constant scalar with the given type +pub fn intern_const_scalar(value: ConstScalar, ty: Ty) -> Const { + ConstData { ty, value: ConstValue::Concrete(chalk_ir::ConcreteConst { interned: value }) } + .intern(Interner) +} + +/// Interns a possibly-unknown target usize +pub fn usize_const(value: Option<u128>) -> Const { + intern_const_scalar(value.map_or(ConstScalar::Unknown, ConstScalar::UInt), TyBuilder::usize()) +} + +pub(crate) fn const_eval_recover( + _: &dyn HirDatabase, + _: &[String], + _: &ConstId, +) -> Result<ComputedExpr, ConstEvalError> { + Err(ConstEvalError::Loop) +} + +pub(crate) fn const_eval_query( + db: &dyn HirDatabase, + const_id: ConstId, +) -> Result<ComputedExpr, ConstEvalError> { + let def = const_id.into(); + let body = db.body(def); + let infer = &db.infer(def); + let result = eval_const( + body.body_expr, + &mut ConstEvalCtx { + db, + owner: const_id.into(), + exprs: &body.exprs, + pats: &body.pats, + local_data: HashMap::default(), + infer, + }, + ); + result +} + +pub(crate) fn eval_to_const<'a>( + expr: Idx<Expr>, + mode: ParamLoweringMode, + ctx: &mut InferenceContext<'a>, + args: impl FnOnce() -> Generics, + debruijn: DebruijnIndex, +) -> Const { + if let Expr::Path(p) = &ctx.body.exprs[expr] { + let db = ctx.db; + let resolver = &ctx.resolver; + if let Some(c) = path_to_const(db, resolver, p.mod_path(), mode, args, debruijn) { + return c; + } + } + let body = ctx.body.clone(); + let mut ctx = ConstEvalCtx { + db: ctx.db, + owner: ctx.owner, + exprs: &body.exprs, + pats: &body.pats, + local_data: HashMap::default(), + infer: &ctx.result, + }; + let computed_expr = eval_const(expr, &mut ctx); + let const_scalar = match computed_expr { + Ok(ComputedExpr::Literal(literal)) => literal.into(), + _ => ConstScalar::Unknown, + }; + intern_const_scalar(const_scalar, TyBuilder::usize()) +} + +#[cfg(test)] +mod tests; diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs new file mode 100644 index 000000000..4a052851a --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs @@ -0,0 +1,148 @@ +use base_db::fixture::WithFixture; +use hir_def::{db::DefDatabase, expr::Literal}; + +use crate::{consteval::ComputedExpr, db::HirDatabase, test_db::TestDB}; + +use super::ConstEvalError; + +fn check_fail(ra_fixture: &str, error: ConstEvalError) { + assert_eq!(eval_goal(ra_fixture), Err(error)); +} + +fn check_number(ra_fixture: &str, answer: i128) { + let r = eval_goal(ra_fixture).unwrap(); + match r { + ComputedExpr::Literal(Literal::Int(r, _)) => assert_eq!(r, answer), + ComputedExpr::Literal(Literal::Uint(r, _)) => assert_eq!(r, answer as u128), + x => panic!("Expected number but found {:?}", x), + } +} + +fn eval_goal(ra_fixture: &str) -> Result<ComputedExpr, ConstEvalError> { + let (db, file_id) = TestDB::with_single_file(ra_fixture); + let module_id = db.module_for_file(file_id); + let def_map = module_id.def_map(&db); + let scope = &def_map[module_id.local_id].scope; + let const_id = scope + .declarations() + .into_iter() + .find_map(|x| match x { + hir_def::ModuleDefId::ConstId(x) => { + if db.const_data(x).name.as_ref()?.to_string() == "GOAL" { + Some(x) + } else { + None + } + } + _ => None, + }) + .unwrap(); + db.const_eval(const_id) +} + +#[test] +fn add() { + check_number(r#"const GOAL: usize = 2 + 2;"#, 4); +} + +#[test] +fn bit_op() { + check_number(r#"const GOAL: u8 = !0 & !(!0 >> 1)"#, 128); + check_number(r#"const GOAL: i8 = !0 & !(!0 >> 1)"#, 0); + // FIXME: rustc evaluate this to -128 + check_fail( + r#"const GOAL: i8 = 1 << 7"#, + ConstEvalError::Panic("attempt to run invalid arithmetic operation".to_string()), + ); + check_fail( + r#"const GOAL: i8 = 1 << 8"#, + ConstEvalError::Panic("attempt to run invalid arithmetic operation".to_string()), + ); +} + +#[test] +fn locals() { + check_number( + r#" + const GOAL: usize = { + let a = 3 + 2; + let b = a * a; + b + }; + "#, + 25, + ); +} + +#[test] +fn consts() { + check_number( + r#" + const F1: i32 = 1; + const F3: i32 = 3 * F2; + const F2: i32 = 2 * F1; + const GOAL: i32 = F3; + "#, + 6, + ); +} + +#[test] +fn const_loop() { + check_fail( + r#" + const F1: i32 = 1 * F3; + const F3: i32 = 3 * F2; + const F2: i32 = 2 * F1; + const GOAL: i32 = F3; + "#, + ConstEvalError::Loop, + ); +} + +#[test] +fn const_impl_assoc() { + check_number( + r#" + struct U5; + impl U5 { + const VAL: usize = 5; + } + const GOAL: usize = U5::VAL; + "#, + 5, + ); +} + +#[test] +fn const_generic_subst() { + // FIXME: this should evaluate to 5 + check_fail( + r#" + struct Adder<const N: usize, const M: usize>; + impl<const N: usize, const M: usize> Adder<N, M> { + const VAL: usize = N + M; + } + const GOAL: usize = Adder::<2, 3>::VAL; + "#, + ConstEvalError::NotSupported("const generic without substitution"), + ); +} + +#[test] +fn const_trait_assoc() { + // FIXME: this should evaluate to 0 + check_fail( + r#" + struct U0; + trait ToConst { + const VAL: usize; + } + impl ToConst for U0 { + const VAL: usize = 0; + } + const GOAL: usize = U0::VAL; + "#, + ConstEvalError::IncompleteExpr, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs new file mode 100644 index 000000000..b385b1caf --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs @@ -0,0 +1,225 @@ +//! The home of `HirDatabase`, which is the Salsa database containing all the +//! type inference-related queries. + +use std::sync::Arc; + +use arrayvec::ArrayVec; +use base_db::{impl_intern_key, salsa, CrateId, Upcast}; +use hir_def::{ + db::DefDatabase, expr::ExprId, BlockId, ConstId, ConstParamId, DefWithBodyId, FunctionId, + GenericDefId, ImplId, LifetimeParamId, LocalFieldId, TypeOrConstParamId, VariantId, +}; +use la_arena::ArenaMap; + +use crate::{ + chalk_db, + consteval::{ComputedExpr, ConstEvalError}, + method_resolution::{InherentImpls, TraitImpls, TyFingerprint}, + Binders, CallableDefId, FnDefId, GenericArg, ImplTraitId, InferenceResult, Interner, PolyFnSig, + QuantifiedWhereClause, ReturnTypeImplTraits, TraitRef, Ty, TyDefId, ValueTyDefId, +}; +use hir_expand::name::Name; + +#[salsa::query_group(HirDatabaseStorage)] +pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> { + #[salsa::invoke(infer_wait)] + #[salsa::transparent] + fn infer(&self, def: DefWithBodyId) -> Arc<InferenceResult>; + + #[salsa::invoke(crate::infer::infer_query)] + fn infer_query(&self, def: DefWithBodyId) -> Arc<InferenceResult>; + + #[salsa::invoke(crate::lower::ty_query)] + #[salsa::cycle(crate::lower::ty_recover)] + fn ty(&self, def: TyDefId) -> Binders<Ty>; + + #[salsa::invoke(crate::lower::value_ty_query)] + fn value_ty(&self, def: ValueTyDefId) -> Binders<Ty>; + + #[salsa::invoke(crate::lower::impl_self_ty_query)] + #[salsa::cycle(crate::lower::impl_self_ty_recover)] + fn impl_self_ty(&self, def: ImplId) -> Binders<Ty>; + + #[salsa::invoke(crate::lower::const_param_ty_query)] + fn const_param_ty(&self, def: ConstParamId) -> Ty; + + #[salsa::invoke(crate::consteval::const_eval_query)] + #[salsa::cycle(crate::consteval::const_eval_recover)] + fn const_eval(&self, def: ConstId) -> Result<ComputedExpr, ConstEvalError>; + + #[salsa::invoke(crate::lower::impl_trait_query)] + fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>; + + #[salsa::invoke(crate::lower::field_types_query)] + fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>; + + #[salsa::invoke(crate::lower::callable_item_sig)] + fn callable_item_signature(&self, def: CallableDefId) -> PolyFnSig; + + #[salsa::invoke(crate::lower::return_type_impl_traits)] + fn return_type_impl_traits( + &self, + def: FunctionId, + ) -> Option<Arc<Binders<ReturnTypeImplTraits>>>; + + #[salsa::invoke(crate::lower::generic_predicates_for_param_query)] + #[salsa::cycle(crate::lower::generic_predicates_for_param_recover)] + fn generic_predicates_for_param( + &self, + def: GenericDefId, + param_id: TypeOrConstParamId, + assoc_name: Option<Name>, + ) -> Arc<[Binders<QuantifiedWhereClause>]>; + + #[salsa::invoke(crate::lower::generic_predicates_query)] + fn generic_predicates(&self, def: GenericDefId) -> Arc<[Binders<QuantifiedWhereClause>]>; + + #[salsa::invoke(crate::lower::trait_environment_query)] + fn trait_environment(&self, def: GenericDefId) -> Arc<crate::TraitEnvironment>; + + #[salsa::invoke(crate::lower::generic_defaults_query)] + #[salsa::cycle(crate::lower::generic_defaults_recover)] + fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<GenericArg>]>; + + #[salsa::invoke(InherentImpls::inherent_impls_in_crate_query)] + fn inherent_impls_in_crate(&self, krate: CrateId) -> Arc<InherentImpls>; + + #[salsa::invoke(InherentImpls::inherent_impls_in_block_query)] + fn inherent_impls_in_block(&self, block: BlockId) -> Option<Arc<InherentImpls>>; + + /// Collects all crates in the dependency graph that have impls for the + /// given fingerprint. This is only used for primitive types; for + /// user-defined types we just look at the crate where the type is defined. + #[salsa::invoke(crate::method_resolution::inherent_impl_crates_query)] + fn inherent_impl_crates(&self, krate: CrateId, fp: TyFingerprint) -> ArrayVec<CrateId, 2>; + + #[salsa::invoke(TraitImpls::trait_impls_in_crate_query)] + fn trait_impls_in_crate(&self, krate: CrateId) -> Arc<TraitImpls>; + + #[salsa::invoke(TraitImpls::trait_impls_in_block_query)] + fn trait_impls_in_block(&self, krate: BlockId) -> Option<Arc<TraitImpls>>; + + #[salsa::invoke(TraitImpls::trait_impls_in_deps_query)] + fn trait_impls_in_deps(&self, krate: CrateId) -> Arc<TraitImpls>; + + // Interned IDs for Chalk integration + #[salsa::interned] + fn intern_callable_def(&self, callable_def: CallableDefId) -> InternedCallableDefId; + #[salsa::interned] + fn intern_type_or_const_param_id( + &self, + param_id: TypeOrConstParamId, + ) -> InternedTypeOrConstParamId; + #[salsa::interned] + fn intern_lifetime_param_id(&self, param_id: LifetimeParamId) -> InternedLifetimeParamId; + #[salsa::interned] + fn intern_impl_trait_id(&self, id: ImplTraitId) -> InternedOpaqueTyId; + #[salsa::interned] + fn intern_closure(&self, id: (DefWithBodyId, ExprId)) -> InternedClosureId; + + #[salsa::invoke(chalk_db::associated_ty_data_query)] + fn associated_ty_data(&self, id: chalk_db::AssocTypeId) -> Arc<chalk_db::AssociatedTyDatum>; + + #[salsa::invoke(chalk_db::trait_datum_query)] + fn trait_datum(&self, krate: CrateId, trait_id: chalk_db::TraitId) + -> Arc<chalk_db::TraitDatum>; + + #[salsa::invoke(chalk_db::struct_datum_query)] + fn struct_datum( + &self, + krate: CrateId, + struct_id: chalk_db::AdtId, + ) -> Arc<chalk_db::StructDatum>; + + #[salsa::invoke(chalk_db::impl_datum_query)] + fn impl_datum(&self, krate: CrateId, impl_id: chalk_db::ImplId) -> Arc<chalk_db::ImplDatum>; + + #[salsa::invoke(chalk_db::fn_def_datum_query)] + fn fn_def_datum(&self, krate: CrateId, fn_def_id: FnDefId) -> Arc<chalk_db::FnDefDatum>; + + #[salsa::invoke(chalk_db::fn_def_variance_query)] + fn fn_def_variance(&self, fn_def_id: FnDefId) -> chalk_db::Variances; + + #[salsa::invoke(chalk_db::adt_variance_query)] + fn adt_variance(&self, adt_id: chalk_db::AdtId) -> chalk_db::Variances; + + #[salsa::invoke(chalk_db::associated_ty_value_query)] + fn associated_ty_value( + &self, + krate: CrateId, + id: chalk_db::AssociatedTyValueId, + ) -> Arc<chalk_db::AssociatedTyValue>; + + #[salsa::invoke(trait_solve_wait)] + #[salsa::transparent] + fn trait_solve( + &self, + krate: CrateId, + goal: crate::Canonical<crate::InEnvironment<crate::Goal>>, + ) -> Option<crate::Solution>; + + #[salsa::invoke(crate::traits::trait_solve_query)] + fn trait_solve_query( + &self, + krate: CrateId, + goal: crate::Canonical<crate::InEnvironment<crate::Goal>>, + ) -> Option<crate::Solution>; + + #[salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)] + fn program_clauses_for_chalk_env( + &self, + krate: CrateId, + env: chalk_ir::Environment<Interner>, + ) -> chalk_ir::ProgramClauses<Interner>; +} + +fn infer_wait(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> { + let _p = profile::span("infer:wait").detail(|| match def { + DefWithBodyId::FunctionId(it) => db.function_data(it).name.to_string(), + DefWithBodyId::StaticId(it) => db.static_data(it).name.clone().to_string(), + DefWithBodyId::ConstId(it) => { + db.const_data(it).name.clone().unwrap_or_else(Name::missing).to_string() + } + }); + db.infer_query(def) +} + +fn trait_solve_wait( + db: &dyn HirDatabase, + krate: CrateId, + goal: crate::Canonical<crate::InEnvironment<crate::Goal>>, +) -> Option<crate::Solution> { + let _p = profile::span("trait_solve::wait"); + db.trait_solve_query(krate, goal) +} + +#[test] +fn hir_database_is_object_safe() { + fn _assert_object_safe(_: &dyn HirDatabase) {} +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct InternedTypeOrConstParamId(salsa::InternId); +impl_intern_key!(InternedTypeOrConstParamId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct InternedLifetimeParamId(salsa::InternId); +impl_intern_key!(InternedLifetimeParamId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct InternedConstParamId(salsa::InternId); +impl_intern_key!(InternedConstParamId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct InternedOpaqueTyId(salsa::InternId); +impl_intern_key!(InternedOpaqueTyId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct InternedClosureId(salsa::InternId); +impl_intern_key!(InternedClosureId); + +/// This exists just for Chalk, because Chalk just has a single `FnDefId` where +/// we have different IDs for struct and enum variant constructors. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)] +pub struct InternedCallableDefId(salsa::InternId); +impl_intern_key!(InternedCallableDefId); diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics.rs new file mode 100644 index 000000000..37eb06be1 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics.rs @@ -0,0 +1,13 @@ +//! Type inference-based diagnostics. +mod expr; +mod match_check; +mod unsafe_check; +mod decl_check; + +pub use crate::diagnostics::{ + decl_check::{incorrect_case, IncorrectCase}, + expr::{ + record_literal_missing_fields, record_pattern_missing_fields, BodyValidationDiagnostic, + }, + unsafe_check::{missing_unsafe, unsafe_expressions, UnsafeExpr}, +}; diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs new file mode 100644 index 000000000..f7031a854 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check.rs @@ -0,0 +1,701 @@ +//! Provides validators for names of declarations. +//! +//! This includes the following items: +//! +//! - variable bindings (e.g. `let x = foo();`) +//! - struct fields (e.g. `struct Foo { field: u8 }`) +//! - enum variants (e.g. `enum Foo { Variant { field: u8 } }`) +//! - function/method arguments (e.g. `fn foo(arg: u8)`) +//! - constants (e.g. `const FOO: u8 = 10;`) +//! - static items (e.g. `static FOO: u8 = 10;`) +//! - match arm bindings (e.g. `foo @ Some(_)`) + +mod case_conv; + +use std::fmt; + +use base_db::CrateId; +use hir_def::{ + adt::VariantData, + expr::{Pat, PatId}, + src::HasSource, + AdtId, AttrDefId, ConstId, EnumId, FunctionId, ItemContainerId, Lookup, ModuleDefId, StaticId, + StructId, +}; +use hir_expand::{ + name::{AsName, Name}, + HirFileId, +}; +use stdx::{always, never}; +use syntax::{ + ast::{self, HasName}, + AstNode, AstPtr, +}; + +use crate::db::HirDatabase; + +use self::case_conv::{to_camel_case, to_lower_snake_case, to_upper_snake_case}; + +mod allow { + pub(super) const BAD_STYLE: &str = "bad_style"; + pub(super) const NONSTANDARD_STYLE: &str = "nonstandard_style"; + pub(super) const NON_SNAKE_CASE: &str = "non_snake_case"; + pub(super) const NON_UPPER_CASE_GLOBAL: &str = "non_upper_case_globals"; + pub(super) const NON_CAMEL_CASE_TYPES: &str = "non_camel_case_types"; +} + +pub fn incorrect_case( + db: &dyn HirDatabase, + krate: CrateId, + owner: ModuleDefId, +) -> Vec<IncorrectCase> { + let _p = profile::span("validate_module_item"); + let mut validator = DeclValidator::new(db, krate); + validator.validate_item(owner); + validator.sink +} + +#[derive(Debug)] +pub enum CaseType { + // `some_var` + LowerSnakeCase, + // `SOME_CONST` + UpperSnakeCase, + // `SomeStruct` + UpperCamelCase, +} + +impl fmt::Display for CaseType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let repr = match self { + CaseType::LowerSnakeCase => "snake_case", + CaseType::UpperSnakeCase => "UPPER_SNAKE_CASE", + CaseType::UpperCamelCase => "CamelCase", + }; + + repr.fmt(f) + } +} + +#[derive(Debug)] +pub enum IdentType { + Constant, + Enum, + Field, + Function, + Parameter, + StaticVariable, + Structure, + Variable, + Variant, +} + +impl fmt::Display for IdentType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let repr = match self { + IdentType::Constant => "Constant", + IdentType::Enum => "Enum", + IdentType::Field => "Field", + IdentType::Function => "Function", + IdentType::Parameter => "Parameter", + IdentType::StaticVariable => "Static variable", + IdentType::Structure => "Structure", + IdentType::Variable => "Variable", + IdentType::Variant => "Variant", + }; + + repr.fmt(f) + } +} + +#[derive(Debug)] +pub struct IncorrectCase { + pub file: HirFileId, + pub ident: AstPtr<ast::Name>, + pub expected_case: CaseType, + pub ident_type: IdentType, + pub ident_text: String, + pub suggested_text: String, +} + +pub(super) struct DeclValidator<'a> { + db: &'a dyn HirDatabase, + krate: CrateId, + pub(super) sink: Vec<IncorrectCase>, +} + +#[derive(Debug)] +struct Replacement { + current_name: Name, + suggested_text: String, + expected_case: CaseType, +} + +impl<'a> DeclValidator<'a> { + pub(super) fn new(db: &'a dyn HirDatabase, krate: CrateId) -> DeclValidator<'a> { + DeclValidator { db, krate, sink: Vec::new() } + } + + pub(super) fn validate_item(&mut self, item: ModuleDefId) { + match item { + ModuleDefId::FunctionId(func) => self.validate_func(func), + ModuleDefId::AdtId(adt) => self.validate_adt(adt), + ModuleDefId::ConstId(const_id) => self.validate_const(const_id), + ModuleDefId::StaticId(static_id) => self.validate_static(static_id), + _ => (), + } + } + + fn validate_adt(&mut self, adt: AdtId) { + match adt { + AdtId::StructId(struct_id) => self.validate_struct(struct_id), + AdtId::EnumId(enum_id) => self.validate_enum(enum_id), + AdtId::UnionId(_) => { + // FIXME: Unions aren't yet supported by this validator. + } + } + } + + /// Checks whether not following the convention is allowed for this item. + fn allowed(&self, id: AttrDefId, allow_name: &str, recursing: bool) -> bool { + let is_allowed = |def_id| { + let attrs = self.db.attrs(def_id); + // don't bug the user about directly no_mangle annotated stuff, they can't do anything about it + (!recursing && attrs.by_key("no_mangle").exists()) + || attrs.by_key("allow").tt_values().any(|tt| { + let allows = tt.to_string(); + allows.contains(allow_name) + || allows.contains(allow::BAD_STYLE) + || allows.contains(allow::NONSTANDARD_STYLE) + }) + }; + + is_allowed(id) + // go upwards one step or give up + || match id { + AttrDefId::ModuleId(m) => m.containing_module(self.db.upcast()).map(|v| v.into()), + AttrDefId::FunctionId(f) => Some(f.lookup(self.db.upcast()).container.into()), + AttrDefId::StaticId(sid) => Some(sid.lookup(self.db.upcast()).container.into()), + AttrDefId::ConstId(cid) => Some(cid.lookup(self.db.upcast()).container.into()), + AttrDefId::TraitId(tid) => Some(tid.lookup(self.db.upcast()).container.into()), + AttrDefId::ImplId(iid) => Some(iid.lookup(self.db.upcast()).container.into()), + AttrDefId::ExternBlockId(id) => Some(id.lookup(self.db.upcast()).container.into()), + // These warnings should not explore macro definitions at all + AttrDefId::MacroId(_) => None, + AttrDefId::AdtId(aid) => match aid { + AdtId::StructId(sid) => Some(sid.lookup(self.db.upcast()).container.into()), + AdtId::EnumId(eid) => Some(eid.lookup(self.db.upcast()).container.into()), + // Unions aren't yet supported + AdtId::UnionId(_) => None, + }, + AttrDefId::FieldId(_) => None, + AttrDefId::EnumVariantId(_) => None, + AttrDefId::TypeAliasId(_) => None, + AttrDefId::GenericParamId(_) => None, + } + .map(|mid| self.allowed(mid, allow_name, true)) + .unwrap_or(false) + } + + fn validate_func(&mut self, func: FunctionId) { + let data = self.db.function_data(func); + if matches!(func.lookup(self.db.upcast()).container, ItemContainerId::ExternBlockId(_)) { + cov_mark::hit!(extern_func_incorrect_case_ignored); + return; + } + + let body = self.db.body(func.into()); + + // Recursively validate inner scope items, such as static variables and constants. + for (_, block_def_map) in body.blocks(self.db.upcast()) { + for (_, module) in block_def_map.modules() { + for def_id in module.scope.declarations() { + let mut validator = DeclValidator::new(self.db, self.krate); + validator.validate_item(def_id); + } + } + } + + // Check whether non-snake case identifiers are allowed for this function. + if self.allowed(func.into(), allow::NON_SNAKE_CASE, false) { + return; + } + + // Check the function name. + let function_name = data.name.to_string(); + let fn_name_replacement = to_lower_snake_case(&function_name).map(|new_name| Replacement { + current_name: data.name.clone(), + suggested_text: new_name, + expected_case: CaseType::LowerSnakeCase, + }); + + // Check the patterns inside the function body. + // This includes function parameters. + let pats_replacements = body + .pats + .iter() + .filter_map(|(id, pat)| match pat { + Pat::Bind { name, .. } => Some((id, name)), + _ => None, + }) + .filter_map(|(id, bind_name)| { + Some(( + id, + Replacement { + current_name: bind_name.clone(), + suggested_text: to_lower_snake_case(&bind_name.to_string())?, + expected_case: CaseType::LowerSnakeCase, + }, + )) + }) + .collect(); + + // If there is at least one element to spawn a warning on, go to the source map and generate a warning. + if let Some(fn_name_replacement) = fn_name_replacement { + self.create_incorrect_case_diagnostic_for_func(func, fn_name_replacement); + } + + self.create_incorrect_case_diagnostic_for_variables(func, pats_replacements); + } + + /// Given the information about incorrect names in the function declaration, looks up into the source code + /// for exact locations and adds diagnostics into the sink. + fn create_incorrect_case_diagnostic_for_func( + &mut self, + func: FunctionId, + fn_name_replacement: Replacement, + ) { + let fn_loc = func.lookup(self.db.upcast()); + let fn_src = fn_loc.source(self.db.upcast()); + + // Diagnostic for function name. + let ast_ptr = match fn_src.value.name() { + Some(name) => name, + None => { + never!( + "Replacement ({:?}) was generated for a function without a name: {:?}", + fn_name_replacement, + fn_src + ); + return; + } + }; + + let diagnostic = IncorrectCase { + file: fn_src.file_id, + ident_type: IdentType::Function, + ident: AstPtr::new(&ast_ptr), + expected_case: fn_name_replacement.expected_case, + ident_text: fn_name_replacement.current_name.to_string(), + suggested_text: fn_name_replacement.suggested_text, + }; + + self.sink.push(diagnostic); + } + + /// Given the information about incorrect variable names, looks up into the source code + /// for exact locations and adds diagnostics into the sink. + fn create_incorrect_case_diagnostic_for_variables( + &mut self, + func: FunctionId, + pats_replacements: Vec<(PatId, Replacement)>, + ) { + // XXX: only look at source_map if we do have missing fields + if pats_replacements.is_empty() { + return; + } + + let (_, source_map) = self.db.body_with_source_map(func.into()); + + for (id, replacement) in pats_replacements { + if let Ok(source_ptr) = source_map.pat_syntax(id) { + if let Some(expr) = source_ptr.value.as_ref().left() { + let root = source_ptr.file_syntax(self.db.upcast()); + if let ast::Pat::IdentPat(ident_pat) = expr.to_node(&root) { + let parent = match ident_pat.syntax().parent() { + Some(parent) => parent, + None => continue, + }; + let name_ast = match ident_pat.name() { + Some(name_ast) => name_ast, + None => continue, + }; + + let is_param = ast::Param::can_cast(parent.kind()); + + // We have to check that it's either `let var = ...` or `var @ Variant(_)` statement, + // because e.g. match arms are patterns as well. + // In other words, we check that it's a named variable binding. + let is_binding = ast::LetStmt::can_cast(parent.kind()) + || (ast::MatchArm::can_cast(parent.kind()) + && ident_pat.at_token().is_some()); + if !(is_param || is_binding) { + // This pattern is not an actual variable declaration, e.g. `Some(val) => {..}` match arm. + continue; + } + + let ident_type = + if is_param { IdentType::Parameter } else { IdentType::Variable }; + + let diagnostic = IncorrectCase { + file: source_ptr.file_id, + ident_type, + ident: AstPtr::new(&name_ast), + expected_case: replacement.expected_case, + ident_text: replacement.current_name.to_string(), + suggested_text: replacement.suggested_text, + }; + + self.sink.push(diagnostic); + } + } + } + } + } + + fn validate_struct(&mut self, struct_id: StructId) { + let data = self.db.struct_data(struct_id); + + let non_camel_case_allowed = + self.allowed(struct_id.into(), allow::NON_CAMEL_CASE_TYPES, false); + let non_snake_case_allowed = self.allowed(struct_id.into(), allow::NON_SNAKE_CASE, false); + + // Check the structure name. + let struct_name = data.name.to_string(); + let struct_name_replacement = if !non_camel_case_allowed { + to_camel_case(&struct_name).map(|new_name| Replacement { + current_name: data.name.clone(), + suggested_text: new_name, + expected_case: CaseType::UpperCamelCase, + }) + } else { + None + }; + + // Check the field names. + let mut struct_fields_replacements = Vec::new(); + + if !non_snake_case_allowed { + if let VariantData::Record(fields) = data.variant_data.as_ref() { + for (_, field) in fields.iter() { + let field_name = field.name.to_string(); + if let Some(new_name) = to_lower_snake_case(&field_name) { + let replacement = Replacement { + current_name: field.name.clone(), + suggested_text: new_name, + expected_case: CaseType::LowerSnakeCase, + }; + struct_fields_replacements.push(replacement); + } + } + } + } + + // If there is at least one element to spawn a warning on, go to the source map and generate a warning. + self.create_incorrect_case_diagnostic_for_struct( + struct_id, + struct_name_replacement, + struct_fields_replacements, + ); + } + + /// Given the information about incorrect names in the struct declaration, looks up into the source code + /// for exact locations and adds diagnostics into the sink. + fn create_incorrect_case_diagnostic_for_struct( + &mut self, + struct_id: StructId, + struct_name_replacement: Option<Replacement>, + struct_fields_replacements: Vec<Replacement>, + ) { + // XXX: Only look at sources if we do have incorrect names. + if struct_name_replacement.is_none() && struct_fields_replacements.is_empty() { + return; + } + + let struct_loc = struct_id.lookup(self.db.upcast()); + let struct_src = struct_loc.source(self.db.upcast()); + + if let Some(replacement) = struct_name_replacement { + let ast_ptr = match struct_src.value.name() { + Some(name) => name, + None => { + never!( + "Replacement ({:?}) was generated for a structure without a name: {:?}", + replacement, + struct_src + ); + return; + } + }; + + let diagnostic = IncorrectCase { + file: struct_src.file_id, + ident_type: IdentType::Structure, + ident: AstPtr::new(&ast_ptr), + expected_case: replacement.expected_case, + ident_text: replacement.current_name.to_string(), + suggested_text: replacement.suggested_text, + }; + + self.sink.push(diagnostic); + } + + let struct_fields_list = match struct_src.value.field_list() { + Some(ast::FieldList::RecordFieldList(fields)) => fields, + _ => { + always!( + struct_fields_replacements.is_empty(), + "Replacements ({:?}) were generated for a structure fields which had no fields list: {:?}", + struct_fields_replacements, + struct_src + ); + return; + } + }; + let mut struct_fields_iter = struct_fields_list.fields(); + for field_to_rename in struct_fields_replacements { + // We assume that parameters in replacement are in the same order as in the + // actual params list, but just some of them (ones that named correctly) are skipped. + let ast_ptr = loop { + match struct_fields_iter.next().and_then(|field| field.name()) { + Some(field_name) => { + if field_name.as_name() == field_to_rename.current_name { + break field_name; + } + } + None => { + never!( + "Replacement ({:?}) was generated for a structure field which was not found: {:?}", + field_to_rename, struct_src + ); + return; + } + } + }; + + let diagnostic = IncorrectCase { + file: struct_src.file_id, + ident_type: IdentType::Field, + ident: AstPtr::new(&ast_ptr), + expected_case: field_to_rename.expected_case, + ident_text: field_to_rename.current_name.to_string(), + suggested_text: field_to_rename.suggested_text, + }; + + self.sink.push(diagnostic); + } + } + + fn validate_enum(&mut self, enum_id: EnumId) { + let data = self.db.enum_data(enum_id); + + // Check whether non-camel case names are allowed for this enum. + if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES, false) { + return; + } + + // Check the enum name. + let enum_name = data.name.to_string(); + let enum_name_replacement = to_camel_case(&enum_name).map(|new_name| Replacement { + current_name: data.name.clone(), + suggested_text: new_name, + expected_case: CaseType::UpperCamelCase, + }); + + // Check the field names. + let enum_fields_replacements = data + .variants + .iter() + .filter_map(|(_, variant)| { + Some(Replacement { + current_name: variant.name.clone(), + suggested_text: to_camel_case(&variant.name.to_string())?, + expected_case: CaseType::UpperCamelCase, + }) + }) + .collect(); + + // If there is at least one element to spawn a warning on, go to the source map and generate a warning. + self.create_incorrect_case_diagnostic_for_enum( + enum_id, + enum_name_replacement, + enum_fields_replacements, + ) + } + + /// Given the information about incorrect names in the struct declaration, looks up into the source code + /// for exact locations and adds diagnostics into the sink. + fn create_incorrect_case_diagnostic_for_enum( + &mut self, + enum_id: EnumId, + enum_name_replacement: Option<Replacement>, + enum_variants_replacements: Vec<Replacement>, + ) { + // XXX: only look at sources if we do have incorrect names + if enum_name_replacement.is_none() && enum_variants_replacements.is_empty() { + return; + } + + let enum_loc = enum_id.lookup(self.db.upcast()); + let enum_src = enum_loc.source(self.db.upcast()); + + if let Some(replacement) = enum_name_replacement { + let ast_ptr = match enum_src.value.name() { + Some(name) => name, + None => { + never!( + "Replacement ({:?}) was generated for a enum without a name: {:?}", + replacement, + enum_src + ); + return; + } + }; + + let diagnostic = IncorrectCase { + file: enum_src.file_id, + ident_type: IdentType::Enum, + ident: AstPtr::new(&ast_ptr), + expected_case: replacement.expected_case, + ident_text: replacement.current_name.to_string(), + suggested_text: replacement.suggested_text, + }; + + self.sink.push(diagnostic); + } + + let enum_variants_list = match enum_src.value.variant_list() { + Some(variants) => variants, + _ => { + always!( + enum_variants_replacements.is_empty(), + "Replacements ({:?}) were generated for a enum variants which had no fields list: {:?}", + enum_variants_replacements, + enum_src + ); + return; + } + }; + let mut enum_variants_iter = enum_variants_list.variants(); + for variant_to_rename in enum_variants_replacements { + // We assume that parameters in replacement are in the same order as in the + // actual params list, but just some of them (ones that named correctly) are skipped. + let ast_ptr = loop { + match enum_variants_iter.next().and_then(|v| v.name()) { + Some(variant_name) => { + if variant_name.as_name() == variant_to_rename.current_name { + break variant_name; + } + } + None => { + never!( + "Replacement ({:?}) was generated for a enum variant which was not found: {:?}", + variant_to_rename, enum_src + ); + return; + } + } + }; + + let diagnostic = IncorrectCase { + file: enum_src.file_id, + ident_type: IdentType::Variant, + ident: AstPtr::new(&ast_ptr), + expected_case: variant_to_rename.expected_case, + ident_text: variant_to_rename.current_name.to_string(), + suggested_text: variant_to_rename.suggested_text, + }; + + self.sink.push(diagnostic); + } + } + + fn validate_const(&mut self, const_id: ConstId) { + let data = self.db.const_data(const_id); + + if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) { + return; + } + + let name = match &data.name { + Some(name) => name, + None => return, + }; + + let const_name = name.to_string(); + let replacement = if let Some(new_name) = to_upper_snake_case(&const_name) { + Replacement { + current_name: name.clone(), + suggested_text: new_name, + expected_case: CaseType::UpperSnakeCase, + } + } else { + // Nothing to do here. + return; + }; + + let const_loc = const_id.lookup(self.db.upcast()); + let const_src = const_loc.source(self.db.upcast()); + + let ast_ptr = match const_src.value.name() { + Some(name) => name, + None => return, + }; + + let diagnostic = IncorrectCase { + file: const_src.file_id, + ident_type: IdentType::Constant, + ident: AstPtr::new(&ast_ptr), + expected_case: replacement.expected_case, + ident_text: replacement.current_name.to_string(), + suggested_text: replacement.suggested_text, + }; + + self.sink.push(diagnostic); + } + + fn validate_static(&mut self, static_id: StaticId) { + let data = self.db.static_data(static_id); + if data.is_extern { + cov_mark::hit!(extern_static_incorrect_case_ignored); + return; + } + + if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL, false) { + return; + } + + let name = &data.name; + + let static_name = name.to_string(); + let replacement = if let Some(new_name) = to_upper_snake_case(&static_name) { + Replacement { + current_name: name.clone(), + suggested_text: new_name, + expected_case: CaseType::UpperSnakeCase, + } + } else { + // Nothing to do here. + return; + }; + + let static_loc = static_id.lookup(self.db.upcast()); + let static_src = static_loc.source(self.db.upcast()); + + let ast_ptr = match static_src.value.name() { + Some(name) => name, + None => return, + }; + + let diagnostic = IncorrectCase { + file: static_src.file_id, + ident_type: IdentType::StaticVariable, + ident: AstPtr::new(&ast_ptr), + expected_case: replacement.expected_case, + ident_text: replacement.current_name.to_string(), + suggested_text: replacement.suggested_text, + }; + + self.sink.push(diagnostic); + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check/case_conv.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check/case_conv.rs new file mode 100644 index 000000000..88d607194 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/decl_check/case_conv.rs @@ -0,0 +1,199 @@ +//! Functions for string case manipulation, such as detecting the identifier case, +//! and converting it into appropriate form. + +// Code that was taken from rustc was taken at commit 89fdb30, +// from file /compiler/rustc_lint/src/nonstandard_style.rs + +/// Converts an identifier to an UpperCamelCase form. +/// Returns `None` if the string is already in UpperCamelCase. +pub(crate) fn to_camel_case(ident: &str) -> Option<String> { + if is_camel_case(ident) { + return None; + } + + // Taken from rustc. + let ret = ident + .trim_matches('_') + .split('_') + .filter(|component| !component.is_empty()) + .map(|component| { + let mut camel_cased_component = String::with_capacity(component.len()); + + let mut new_word = true; + let mut prev_is_lower_case = true; + + for c in component.chars() { + // Preserve the case if an uppercase letter follows a lowercase letter, so that + // `camelCase` is converted to `CamelCase`. + if prev_is_lower_case && c.is_uppercase() { + new_word = true; + } + + if new_word { + camel_cased_component.extend(c.to_uppercase()); + } else { + camel_cased_component.extend(c.to_lowercase()); + } + + prev_is_lower_case = c.is_lowercase(); + new_word = false; + } + + camel_cased_component + }) + .fold((String::new(), None), |(acc, prev): (_, Option<String>), next| { + // separate two components with an underscore if their boundary cannot + // be distinguished using an uppercase/lowercase case distinction + let join = prev + .and_then(|prev| { + let f = next.chars().next()?; + let l = prev.chars().last()?; + Some(!char_has_case(l) && !char_has_case(f)) + }) + .unwrap_or(false); + (acc + if join { "_" } else { "" } + &next, Some(next)) + }) + .0; + Some(ret) +} + +/// Converts an identifier to a lower_snake_case form. +/// Returns `None` if the string is already in lower_snake_case. +pub(crate) fn to_lower_snake_case(ident: &str) -> Option<String> { + if is_lower_snake_case(ident) { + return None; + } else if is_upper_snake_case(ident) { + return Some(ident.to_lowercase()); + } + + Some(stdx::to_lower_snake_case(ident)) +} + +/// Converts an identifier to an UPPER_SNAKE_CASE form. +/// Returns `None` if the string is already is UPPER_SNAKE_CASE. +pub(crate) fn to_upper_snake_case(ident: &str) -> Option<String> { + if is_upper_snake_case(ident) { + return None; + } else if is_lower_snake_case(ident) { + return Some(ident.to_uppercase()); + } + + Some(stdx::to_upper_snake_case(ident)) +} + +// Taken from rustc. +// Modified by replacing the use of unstable feature `array_windows`. +fn is_camel_case(name: &str) -> bool { + let name = name.trim_matches('_'); + if name.is_empty() { + return true; + } + + let mut fst = None; + // start with a non-lowercase letter rather than non-uppercase + // ones (some scripts don't have a concept of upper/lowercase) + name.chars().next().map_or(true, |c| !c.is_lowercase()) + && !name.contains("__") + && !name.chars().any(|snd| { + let ret = match fst { + None => false, + Some(fst) => char_has_case(fst) && snd == '_' || char_has_case(snd) && fst == '_', + }; + fst = Some(snd); + + ret + }) +} + +fn is_lower_snake_case(ident: &str) -> bool { + is_snake_case(ident, char::is_uppercase) +} + +fn is_upper_snake_case(ident: &str) -> bool { + is_snake_case(ident, char::is_lowercase) +} + +// Taken from rustc. +// Modified to allow checking for both upper and lower snake case. +fn is_snake_case<F: Fn(char) -> bool>(ident: &str, wrong_case: F) -> bool { + if ident.is_empty() { + return true; + } + let ident = ident.trim_matches('_'); + + let mut allow_underscore = true; + ident.chars().all(|c| { + allow_underscore = match c { + '_' if !allow_underscore => return false, + '_' => false, + // It would be more obvious to check for the correct case, + // but some characters do not have a case. + c if !wrong_case(c) => true, + _ => return false, + }; + true + }) +} + +// Taken from rustc. +fn char_has_case(c: char) -> bool { + c.is_lowercase() || c.is_uppercase() +} + +#[cfg(test)] +mod tests { + use super::*; + use expect_test::{expect, Expect}; + + fn check<F: Fn(&str) -> Option<String>>(fun: F, input: &str, expect: Expect) { + // `None` is translated to empty string, meaning that there is nothing to fix. + let output = fun(input).unwrap_or_default(); + + expect.assert_eq(&output); + } + + #[test] + fn test_to_lower_snake_case() { + check(to_lower_snake_case, "lower_snake_case", expect![[""]]); + check(to_lower_snake_case, "UPPER_SNAKE_CASE", expect![["upper_snake_case"]]); + check(to_lower_snake_case, "Weird_Case", expect![["weird_case"]]); + check(to_lower_snake_case, "CamelCase", expect![["camel_case"]]); + check(to_lower_snake_case, "lowerCamelCase", expect![["lower_camel_case"]]); + check(to_lower_snake_case, "a", expect![[""]]); + check(to_lower_snake_case, "abc", expect![[""]]); + check(to_lower_snake_case, "foo__bar", expect![["foo_bar"]]); + } + + #[test] + fn test_to_camel_case() { + check(to_camel_case, "CamelCase", expect![[""]]); + check(to_camel_case, "CamelCase_", expect![[""]]); + check(to_camel_case, "_CamelCase", expect![[""]]); + check(to_camel_case, "lowerCamelCase", expect![["LowerCamelCase"]]); + check(to_camel_case, "lower_snake_case", expect![["LowerSnakeCase"]]); + check(to_camel_case, "UPPER_SNAKE_CASE", expect![["UpperSnakeCase"]]); + check(to_camel_case, "Weird_Case", expect![["WeirdCase"]]); + check(to_camel_case, "name", expect![["Name"]]); + check(to_camel_case, "A", expect![[""]]); + check(to_camel_case, "AABB", expect![[""]]); + // Taken from rustc: /compiler/rustc_lint/src/nonstandard_style/tests.rs + check(to_camel_case, "X86_64", expect![[""]]); + check(to_camel_case, "x86__64", expect![["X86_64"]]); + check(to_camel_case, "Abc_123", expect![["Abc123"]]); + check(to_camel_case, "A1_b2_c3", expect![["A1B2C3"]]); + } + + #[test] + fn test_to_upper_snake_case() { + check(to_upper_snake_case, "UPPER_SNAKE_CASE", expect![[""]]); + check(to_upper_snake_case, "lower_snake_case", expect![["LOWER_SNAKE_CASE"]]); + check(to_upper_snake_case, "Weird_Case", expect![["WEIRD_CASE"]]); + check(to_upper_snake_case, "CamelCase", expect![["CAMEL_CASE"]]); + check(to_upper_snake_case, "lowerCamelCase", expect![["LOWER_CAMEL_CASE"]]); + check(to_upper_snake_case, "A", expect![[""]]); + check(to_upper_snake_case, "ABC", expect![[""]]); + check(to_upper_snake_case, "X86_64", expect![[""]]); + check(to_upper_snake_case, "FOO_BAr", expect![["FOO_BAR"]]); + check(to_upper_snake_case, "FOO__BAR", expect![["FOO_BAR"]]); + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs new file mode 100644 index 000000000..642e03edd --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs @@ -0,0 +1,416 @@ +//! Various diagnostics for expressions that are collected together in one pass +//! through the body using inference results: mismatched arg counts, missing +//! fields, etc. + +use std::fmt; +use std::sync::Arc; + +use hir_def::{path::path, resolver::HasResolver, AdtId, AssocItemId, DefWithBodyId, HasModule}; +use hir_expand::name; +use itertools::Either; +use itertools::Itertools; +use rustc_hash::FxHashSet; +use typed_arena::Arena; + +use crate::{ + db::HirDatabase, + diagnostics::match_check::{ + self, + deconstruct_pat::DeconstructedPat, + usefulness::{compute_match_usefulness, MatchCheckCtx}, + }, + display::HirDisplay, + InferenceResult, Ty, TyExt, +}; + +pub(crate) use hir_def::{ + body::Body, + expr::{Expr, ExprId, MatchArm, Pat, PatId}, + LocalFieldId, VariantId, +}; + +pub enum BodyValidationDiagnostic { + RecordMissingFields { + record: Either<ExprId, PatId>, + variant: VariantId, + missed_fields: Vec<LocalFieldId>, + }, + ReplaceFilterMapNextWithFindMap { + method_call_expr: ExprId, + }, + MissingMatchArms { + match_expr: ExprId, + uncovered_patterns: String, + }, +} + +impl BodyValidationDiagnostic { + pub fn collect(db: &dyn HirDatabase, owner: DefWithBodyId) -> Vec<BodyValidationDiagnostic> { + let _p = profile::span("BodyValidationDiagnostic::collect"); + let infer = db.infer(owner); + let mut validator = ExprValidator::new(owner, infer); + validator.validate_body(db); + validator.diagnostics + } +} + +struct ExprValidator { + owner: DefWithBodyId, + infer: Arc<InferenceResult>, + pub(super) diagnostics: Vec<BodyValidationDiagnostic>, +} + +impl ExprValidator { + fn new(owner: DefWithBodyId, infer: Arc<InferenceResult>) -> ExprValidator { + ExprValidator { owner, infer, diagnostics: Vec::new() } + } + + fn validate_body(&mut self, db: &dyn HirDatabase) { + let body = db.body(self.owner); + let mut filter_map_next_checker = None; + + for (id, expr) in body.exprs.iter() { + if let Some((variant, missed_fields, true)) = + record_literal_missing_fields(db, &self.infer, id, expr) + { + self.diagnostics.push(BodyValidationDiagnostic::RecordMissingFields { + record: Either::Left(id), + variant, + missed_fields, + }); + } + + match expr { + Expr::Match { expr, arms } => { + self.validate_match(id, *expr, arms, db, self.infer.clone()); + } + Expr::Call { .. } | Expr::MethodCall { .. } => { + self.validate_call(db, id, expr, &mut filter_map_next_checker); + } + _ => {} + } + } + for (id, pat) in body.pats.iter() { + if let Some((variant, missed_fields, true)) = + record_pattern_missing_fields(db, &self.infer, id, pat) + { + self.diagnostics.push(BodyValidationDiagnostic::RecordMissingFields { + record: Either::Right(id), + variant, + missed_fields, + }); + } + } + } + + fn validate_call( + &mut self, + db: &dyn HirDatabase, + call_id: ExprId, + expr: &Expr, + filter_map_next_checker: &mut Option<FilterMapNextChecker>, + ) { + // Check that the number of arguments matches the number of parameters. + + // FIXME: Due to shortcomings in the current type system implementation, only emit this + // diagnostic if there are no type mismatches in the containing function. + if self.infer.expr_type_mismatches().next().is_some() { + return; + } + + match expr { + Expr::MethodCall { receiver, .. } => { + let (callee, _) = match self.infer.method_resolution(call_id) { + Some(it) => it, + None => return, + }; + + if filter_map_next_checker + .get_or_insert_with(|| { + FilterMapNextChecker::new(&self.owner.resolver(db.upcast()), db) + }) + .check(call_id, receiver, &callee) + .is_some() + { + self.diagnostics.push( + BodyValidationDiagnostic::ReplaceFilterMapNextWithFindMap { + method_call_expr: call_id, + }, + ); + } + } + _ => return, + }; + } + + fn validate_match( + &mut self, + id: ExprId, + match_expr: ExprId, + arms: &[MatchArm], + db: &dyn HirDatabase, + infer: Arc<InferenceResult>, + ) { + let body = db.body(self.owner); + + let match_expr_ty = &infer[match_expr]; + if match_expr_ty.is_unknown() { + return; + } + + let pattern_arena = Arena::new(); + let cx = MatchCheckCtx { + module: self.owner.module(db.upcast()), + body: self.owner, + db, + pattern_arena: &pattern_arena, + }; + + let mut m_arms = Vec::with_capacity(arms.len()); + let mut has_lowering_errors = false; + for arm in arms { + if let Some(pat_ty) = infer.type_of_pat.get(arm.pat) { + // We only include patterns whose type matches the type + // of the match expression. If we had an InvalidMatchArmPattern + // diagnostic or similar we could raise that in an else + // block here. + // + // When comparing the types, we also have to consider that rustc + // will automatically de-reference the match expression type if + // necessary. + // + // FIXME we should use the type checker for this. + if (pat_ty == match_expr_ty + || match_expr_ty + .as_reference() + .map(|(match_expr_ty, ..)| match_expr_ty == pat_ty) + .unwrap_or(false)) + && types_of_subpatterns_do_match(arm.pat, &body, &infer) + { + // If we had a NotUsefulMatchArm diagnostic, we could + // check the usefulness of each pattern as we added it + // to the matrix here. + let m_arm = match_check::MatchArm { + pat: self.lower_pattern(&cx, arm.pat, db, &body, &mut has_lowering_errors), + has_guard: arm.guard.is_some(), + }; + m_arms.push(m_arm); + if !has_lowering_errors { + continue; + } + } + } + + // If we can't resolve the type of a pattern, or the pattern type doesn't + // fit the match expression, we skip this diagnostic. Skipping the entire + // diagnostic rather than just not including this match arm is preferred + // to avoid the chance of false positives. + cov_mark::hit!(validate_match_bailed_out); + return; + } + + let report = compute_match_usefulness(&cx, &m_arms, match_expr_ty); + + // FIXME Report unreacheble arms + // https://github.com/rust-lang/rust/blob/f31622a50/compiler/rustc_mir_build/src/thir/pattern/check_match.rs#L200 + + let witnesses = report.non_exhaustiveness_witnesses; + if !witnesses.is_empty() { + self.diagnostics.push(BodyValidationDiagnostic::MissingMatchArms { + match_expr: id, + uncovered_patterns: missing_match_arms(&cx, match_expr_ty, witnesses, arms), + }); + } + } + + fn lower_pattern<'p>( + &self, + cx: &MatchCheckCtx<'_, 'p>, + pat: PatId, + db: &dyn HirDatabase, + body: &Body, + have_errors: &mut bool, + ) -> &'p DeconstructedPat<'p> { + let mut patcx = match_check::PatCtxt::new(db, &self.infer, body); + let pattern = patcx.lower_pattern(pat); + let pattern = cx.pattern_arena.alloc(DeconstructedPat::from_pat(cx, &pattern)); + if !patcx.errors.is_empty() { + *have_errors = true; + } + pattern + } +} + +struct FilterMapNextChecker { + filter_map_function_id: Option<hir_def::FunctionId>, + next_function_id: Option<hir_def::FunctionId>, + prev_filter_map_expr_id: Option<ExprId>, +} + +impl FilterMapNextChecker { + fn new(resolver: &hir_def::resolver::Resolver, db: &dyn HirDatabase) -> Self { + // Find and store the FunctionIds for Iterator::filter_map and Iterator::next + let iterator_path = path![core::iter::Iterator]; + let mut filter_map_function_id = None; + let mut next_function_id = None; + + if let Some(iterator_trait_id) = resolver.resolve_known_trait(db.upcast(), &iterator_path) { + let iterator_trait_items = &db.trait_data(iterator_trait_id).items; + for item in iterator_trait_items.iter() { + if let (name, AssocItemId::FunctionId(id)) = item { + if *name == name![filter_map] { + filter_map_function_id = Some(*id); + } + if *name == name![next] { + next_function_id = Some(*id); + } + } + if filter_map_function_id.is_some() && next_function_id.is_some() { + break; + } + } + } + Self { filter_map_function_id, next_function_id, prev_filter_map_expr_id: None } + } + + // check for instances of .filter_map(..).next() + fn check( + &mut self, + current_expr_id: ExprId, + receiver_expr_id: &ExprId, + function_id: &hir_def::FunctionId, + ) -> Option<()> { + if *function_id == self.filter_map_function_id? { + self.prev_filter_map_expr_id = Some(current_expr_id); + return None; + } + + if *function_id == self.next_function_id? { + if let Some(prev_filter_map_expr_id) = self.prev_filter_map_expr_id { + if *receiver_expr_id == prev_filter_map_expr_id { + return Some(()); + } + } + } + + self.prev_filter_map_expr_id = None; + None + } +} + +pub fn record_literal_missing_fields( + db: &dyn HirDatabase, + infer: &InferenceResult, + id: ExprId, + expr: &Expr, +) -> Option<(VariantId, Vec<LocalFieldId>, /*exhaustive*/ bool)> { + let (fields, exhaustive) = match expr { + Expr::RecordLit { fields, spread, ellipsis, is_assignee_expr, .. } => { + let exhaustive = if *is_assignee_expr { !*ellipsis } else { spread.is_none() }; + (fields, exhaustive) + } + _ => return None, + }; + + let variant_def = infer.variant_resolution_for_expr(id)?; + if let VariantId::UnionId(_) = variant_def { + return None; + } + + let variant_data = variant_def.variant_data(db.upcast()); + + let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect(); + let missed_fields: Vec<LocalFieldId> = variant_data + .fields() + .iter() + .filter_map(|(f, d)| if specified_fields.contains(&d.name) { None } else { Some(f) }) + .collect(); + if missed_fields.is_empty() { + return None; + } + Some((variant_def, missed_fields, exhaustive)) +} + +pub fn record_pattern_missing_fields( + db: &dyn HirDatabase, + infer: &InferenceResult, + id: PatId, + pat: &Pat, +) -> Option<(VariantId, Vec<LocalFieldId>, /*exhaustive*/ bool)> { + let (fields, exhaustive) = match pat { + Pat::Record { path: _, args, ellipsis } => (args, !ellipsis), + _ => return None, + }; + + let variant_def = infer.variant_resolution_for_pat(id)?; + if let VariantId::UnionId(_) = variant_def { + return None; + } + + let variant_data = variant_def.variant_data(db.upcast()); + + let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect(); + let missed_fields: Vec<LocalFieldId> = variant_data + .fields() + .iter() + .filter_map(|(f, d)| if specified_fields.contains(&d.name) { None } else { Some(f) }) + .collect(); + if missed_fields.is_empty() { + return None; + } + Some((variant_def, missed_fields, exhaustive)) +} + +fn types_of_subpatterns_do_match(pat: PatId, body: &Body, infer: &InferenceResult) -> bool { + fn walk(pat: PatId, body: &Body, infer: &InferenceResult, has_type_mismatches: &mut bool) { + match infer.type_mismatch_for_pat(pat) { + Some(_) => *has_type_mismatches = true, + None => { + body[pat].walk_child_pats(|subpat| walk(subpat, body, infer, has_type_mismatches)) + } + } + } + + let mut has_type_mismatches = false; + walk(pat, body, infer, &mut has_type_mismatches); + !has_type_mismatches +} + +fn missing_match_arms<'p>( + cx: &MatchCheckCtx<'_, 'p>, + scrut_ty: &Ty, + witnesses: Vec<DeconstructedPat<'p>>, + arms: &[MatchArm], +) -> String { + struct DisplayWitness<'a, 'p>(&'a DeconstructedPat<'p>, &'a MatchCheckCtx<'a, 'p>); + impl<'a, 'p> fmt::Display for DisplayWitness<'a, 'p> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let DisplayWitness(witness, cx) = *self; + let pat = witness.to_pat(cx); + write!(f, "{}", pat.display(cx.db)) + } + } + + let non_empty_enum = match scrut_ty.as_adt() { + Some((AdtId::EnumId(e), _)) => !cx.db.enum_data(e).variants.is_empty(), + _ => false, + }; + if arms.is_empty() && !non_empty_enum { + format!("type `{}` is non-empty", scrut_ty.display(cx.db)) + } else { + let pat_display = |witness| DisplayWitness(witness, cx); + const LIMIT: usize = 3; + match &*witnesses { + [witness] => format!("`{}` not covered", pat_display(witness)), + [head @ .., tail] if head.len() < LIMIT => { + let head = head.iter().map(pat_display); + format!("`{}` and `{}` not covered", head.format("`, `"), pat_display(tail)) + } + _ => { + let (head, tail) = witnesses.split_at(LIMIT); + let head = head.iter().map(pat_display); + format!("`{}` and {} more not covered", head.format("`, `"), tail.len()) + } + } + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check.rs new file mode 100644 index 000000000..d51ad72bd --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check.rs @@ -0,0 +1,508 @@ +//! Validation of matches. +//! +//! This module provides lowering from [hir_def::expr::Pat] to [self::Pat] and match +//! checking algorithm. +//! +//! It is modeled on the rustc module `rustc_mir_build::thir::pattern`. + +mod pat_util; + +pub(crate) mod deconstruct_pat; +pub(crate) mod usefulness; + +use chalk_ir::Mutability; +use hir_def::{ + adt::VariantData, body::Body, expr::PatId, AdtId, EnumVariantId, HasModule, LocalFieldId, + VariantId, +}; +use hir_expand::name::{name, Name}; +use stdx::{always, never}; + +use crate::{ + db::HirDatabase, + display::{HirDisplay, HirDisplayError, HirFormatter}, + infer::BindingMode, + InferenceResult, Interner, Substitution, Ty, TyExt, TyKind, +}; + +use self::pat_util::EnumerateAndAdjustIterator; + +pub(crate) use self::usefulness::MatchArm; + +#[derive(Clone, Debug)] +pub(crate) enum PatternError { + Unimplemented, + UnexpectedType, + UnresolvedVariant, + MissingField, + ExtraFields, +} + +#[derive(Clone, Debug, PartialEq)] +pub(crate) struct FieldPat { + pub(crate) field: LocalFieldId, + pub(crate) pattern: Pat, +} + +#[derive(Clone, Debug, PartialEq)] +pub(crate) struct Pat { + pub(crate) ty: Ty, + pub(crate) kind: Box<PatKind>, +} + +/// Close relative to `rustc_mir_build::thir::pattern::PatKind` +#[derive(Clone, Debug, PartialEq)] +pub(crate) enum PatKind { + Wild, + + /// `x`, `ref x`, `x @ P`, etc. + Binding { + name: Name, + subpattern: Option<Pat>, + }, + + /// `Foo(...)` or `Foo{...}` or `Foo`, where `Foo` is a variant name from an ADT with + /// multiple variants. + Variant { + substs: Substitution, + enum_variant: EnumVariantId, + subpatterns: Vec<FieldPat>, + }, + + /// `(...)`, `Foo(...)`, `Foo{...}`, or `Foo`, where `Foo` is a variant name from an ADT with + /// a single variant. + Leaf { + subpatterns: Vec<FieldPat>, + }, + + /// `box P`, `&P`, `&mut P`, etc. + Deref { + subpattern: Pat, + }, + + // FIXME: for now, only bool literals are implemented + LiteralBool { + value: bool, + }, + + /// An or-pattern, e.g. `p | q`. + /// Invariant: `pats.len() >= 2`. + Or { + pats: Vec<Pat>, + }, +} + +pub(crate) struct PatCtxt<'a> { + db: &'a dyn HirDatabase, + infer: &'a InferenceResult, + body: &'a Body, + pub(crate) errors: Vec<PatternError>, +} + +impl<'a> PatCtxt<'a> { + pub(crate) fn new(db: &'a dyn HirDatabase, infer: &'a InferenceResult, body: &'a Body) -> Self { + Self { db, infer, body, errors: Vec::new() } + } + + pub(crate) fn lower_pattern(&mut self, pat: PatId) -> Pat { + // XXX(iDawer): Collecting pattern adjustments feels imprecise to me. + // When lowering of & and box patterns are implemented this should be tested + // in a manner of `match_ergonomics_issue_9095` test. + // Pattern adjustment is part of RFC 2005-match-ergonomics. + // More info https://github.com/rust-lang/rust/issues/42640#issuecomment-313535089 + let unadjusted_pat = self.lower_pattern_unadjusted(pat); + self.infer.pat_adjustments.get(&pat).map(|it| &**it).unwrap_or_default().iter().rev().fold( + unadjusted_pat, + |subpattern, ref_ty| Pat { + ty: ref_ty.clone(), + kind: Box::new(PatKind::Deref { subpattern }), + }, + ) + } + + fn lower_pattern_unadjusted(&mut self, pat: PatId) -> Pat { + let mut ty = &self.infer[pat]; + let variant = self.infer.variant_resolution_for_pat(pat); + + let kind = match self.body[pat] { + hir_def::expr::Pat::Wild => PatKind::Wild, + + hir_def::expr::Pat::Lit(expr) => self.lower_lit(expr), + + hir_def::expr::Pat::Path(ref path) => { + return self.lower_path(pat, path); + } + + hir_def::expr::Pat::Tuple { ref args, ellipsis } => { + let arity = match *ty.kind(Interner) { + TyKind::Tuple(arity, _) => arity, + _ => { + never!("unexpected type for tuple pattern: {:?}", ty); + self.errors.push(PatternError::UnexpectedType); + return Pat { ty: ty.clone(), kind: PatKind::Wild.into() }; + } + }; + let subpatterns = self.lower_tuple_subpats(args, arity, ellipsis); + PatKind::Leaf { subpatterns } + } + + hir_def::expr::Pat::Bind { ref name, subpat, .. } => { + let bm = self.infer.pat_binding_modes[&pat]; + match (bm, ty.kind(Interner)) { + (BindingMode::Ref(_), TyKind::Ref(.., rty)) => ty = rty, + (BindingMode::Ref(_), _) => { + never!("`ref {}` has wrong type {:?}", name, ty); + self.errors.push(PatternError::UnexpectedType); + return Pat { ty: ty.clone(), kind: PatKind::Wild.into() }; + } + _ => (), + } + PatKind::Binding { name: name.clone(), subpattern: self.lower_opt_pattern(subpat) } + } + + hir_def::expr::Pat::TupleStruct { ref args, ellipsis, .. } if variant.is_some() => { + let expected_len = variant.unwrap().variant_data(self.db.upcast()).fields().len(); + let subpatterns = self.lower_tuple_subpats(args, expected_len, ellipsis); + self.lower_variant_or_leaf(pat, ty, subpatterns) + } + + hir_def::expr::Pat::Record { ref args, .. } if variant.is_some() => { + let variant_data = variant.unwrap().variant_data(self.db.upcast()); + let subpatterns = args + .iter() + .map(|field| { + // XXX(iDawer): field lookup is inefficient + variant_data.field(&field.name).map(|lfield_id| FieldPat { + field: lfield_id, + pattern: self.lower_pattern(field.pat), + }) + }) + .collect(); + match subpatterns { + Some(subpatterns) => self.lower_variant_or_leaf(pat, ty, subpatterns), + None => { + self.errors.push(PatternError::MissingField); + PatKind::Wild + } + } + } + hir_def::expr::Pat::TupleStruct { .. } | hir_def::expr::Pat::Record { .. } => { + self.errors.push(PatternError::UnresolvedVariant); + PatKind::Wild + } + + hir_def::expr::Pat::Or(ref pats) => PatKind::Or { pats: self.lower_patterns(pats) }, + + _ => { + self.errors.push(PatternError::Unimplemented); + PatKind::Wild + } + }; + + Pat { ty: ty.clone(), kind: Box::new(kind) } + } + + fn lower_tuple_subpats( + &mut self, + pats: &[PatId], + expected_len: usize, + ellipsis: Option<usize>, + ) -> Vec<FieldPat> { + if pats.len() > expected_len { + self.errors.push(PatternError::ExtraFields); + return Vec::new(); + } + + pats.iter() + .enumerate_and_adjust(expected_len, ellipsis) + .map(|(i, &subpattern)| FieldPat { + field: LocalFieldId::from_raw((i as u32).into()), + pattern: self.lower_pattern(subpattern), + }) + .collect() + } + + fn lower_patterns(&mut self, pats: &[PatId]) -> Vec<Pat> { + pats.iter().map(|&p| self.lower_pattern(p)).collect() + } + + fn lower_opt_pattern(&mut self, pat: Option<PatId>) -> Option<Pat> { + pat.map(|p| self.lower_pattern(p)) + } + + fn lower_variant_or_leaf( + &mut self, + pat: PatId, + ty: &Ty, + subpatterns: Vec<FieldPat>, + ) -> PatKind { + let kind = match self.infer.variant_resolution_for_pat(pat) { + Some(variant_id) => { + if let VariantId::EnumVariantId(enum_variant) = variant_id { + let substs = match ty.kind(Interner) { + TyKind::Adt(_, substs) => substs.clone(), + kind => { + always!( + matches!(kind, TyKind::FnDef(..) | TyKind::Error), + "inappropriate type for def: {:?}", + ty + ); + self.errors.push(PatternError::UnexpectedType); + return PatKind::Wild; + } + }; + PatKind::Variant { substs, enum_variant, subpatterns } + } else { + PatKind::Leaf { subpatterns } + } + } + None => { + self.errors.push(PatternError::UnresolvedVariant); + PatKind::Wild + } + }; + kind + } + + fn lower_path(&mut self, pat: PatId, _path: &hir_def::path::Path) -> Pat { + let ty = &self.infer[pat]; + + let pat_from_kind = |kind| Pat { ty: ty.clone(), kind: Box::new(kind) }; + + match self.infer.variant_resolution_for_pat(pat) { + Some(_) => pat_from_kind(self.lower_variant_or_leaf(pat, ty, Vec::new())), + None => { + self.errors.push(PatternError::UnresolvedVariant); + pat_from_kind(PatKind::Wild) + } + } + } + + fn lower_lit(&mut self, expr: hir_def::expr::ExprId) -> PatKind { + use hir_def::expr::{Expr, Literal::Bool}; + + match self.body[expr] { + Expr::Literal(Bool(value)) => PatKind::LiteralBool { value }, + _ => { + self.errors.push(PatternError::Unimplemented); + PatKind::Wild + } + } + } +} + +impl HirDisplay for Pat { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match &*self.kind { + PatKind::Wild => write!(f, "_"), + PatKind::Binding { name, subpattern } => { + write!(f, "{name}")?; + if let Some(subpattern) = subpattern { + write!(f, " @ ")?; + subpattern.hir_fmt(f)?; + } + Ok(()) + } + PatKind::Variant { subpatterns, .. } | PatKind::Leaf { subpatterns } => { + let variant = match *self.kind { + PatKind::Variant { enum_variant, .. } => Some(VariantId::from(enum_variant)), + _ => self.ty.as_adt().and_then(|(adt, _)| match adt { + AdtId::StructId(s) => Some(s.into()), + AdtId::UnionId(u) => Some(u.into()), + AdtId::EnumId(_) => None, + }), + }; + + if let Some(variant) = variant { + match variant { + VariantId::EnumVariantId(v) => { + let data = f.db.enum_data(v.parent); + write!(f, "{}", data.variants[v.local_id].name)?; + } + VariantId::StructId(s) => write!(f, "{}", f.db.struct_data(s).name)?, + VariantId::UnionId(u) => write!(f, "{}", f.db.union_data(u).name)?, + }; + + let variant_data = variant.variant_data(f.db.upcast()); + if let VariantData::Record(rec_fields) = &*variant_data { + write!(f, " {{ ")?; + + let mut printed = 0; + let subpats = subpatterns + .iter() + .filter(|p| !matches!(*p.pattern.kind, PatKind::Wild)) + .map(|p| { + printed += 1; + WriteWith(move |f| { + write!(f, "{}: ", rec_fields[p.field].name)?; + p.pattern.hir_fmt(f) + }) + }); + f.write_joined(subpats, ", ")?; + + if printed < rec_fields.len() { + write!(f, "{}..", if printed > 0 { ", " } else { "" })?; + } + + return write!(f, " }}"); + } + } + + let num_fields = variant + .map_or(subpatterns.len(), |v| v.variant_data(f.db.upcast()).fields().len()); + if num_fields != 0 || variant.is_none() { + write!(f, "(")?; + let subpats = (0..num_fields).map(|i| { + WriteWith(move |f| { + let fid = LocalFieldId::from_raw((i as u32).into()); + if let Some(p) = subpatterns.get(i) { + if p.field == fid { + return p.pattern.hir_fmt(f); + } + } + if let Some(p) = subpatterns.iter().find(|p| p.field == fid) { + p.pattern.hir_fmt(f) + } else { + write!(f, "_") + } + }) + }); + f.write_joined(subpats, ", ")?; + if let (TyKind::Tuple(..), 1) = (self.ty.kind(Interner), num_fields) { + write!(f, ",")?; + } + write!(f, ")")?; + } + + Ok(()) + } + PatKind::Deref { subpattern } => { + match self.ty.kind(Interner) { + TyKind::Adt(adt, _) if is_box(adt.0, f.db) => write!(f, "box ")?, + &TyKind::Ref(mutbl, ..) => { + write!(f, "&{}", if mutbl == Mutability::Mut { "mut " } else { "" })? + } + _ => never!("{:?} is a bad Deref pattern type", self.ty), + } + subpattern.hir_fmt(f) + } + PatKind::LiteralBool { value } => write!(f, "{}", value), + PatKind::Or { pats } => f.write_joined(pats.iter(), " | "), + } + } +} + +struct WriteWith<F>(F) +where + F: Fn(&mut HirFormatter<'_>) -> Result<(), HirDisplayError>; + +impl<F> HirDisplay for WriteWith<F> +where + F: Fn(&mut HirFormatter<'_>) -> Result<(), HirDisplayError>, +{ + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + (self.0)(f) + } +} + +fn is_box(adt: AdtId, db: &dyn HirDatabase) -> bool { + let owned_box = name![owned_box].to_smol_str(); + let krate = adt.module(db.upcast()).krate(); + let box_adt = db.lang_item(krate, owned_box).and_then(|it| it.as_struct()).map(AdtId::from); + Some(adt) == box_adt +} + +pub(crate) trait PatternFoldable: Sized { + fn fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + self.super_fold_with(folder) + } + + fn super_fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self; +} + +pub(crate) trait PatternFolder: Sized { + fn fold_pattern(&mut self, pattern: &Pat) -> Pat { + pattern.super_fold_with(self) + } + + fn fold_pattern_kind(&mut self, kind: &PatKind) -> PatKind { + kind.super_fold_with(self) + } +} + +impl<T: PatternFoldable> PatternFoldable for Box<T> { + fn super_fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + let content: T = (**self).fold_with(folder); + Box::new(content) + } +} + +impl<T: PatternFoldable> PatternFoldable for Vec<T> { + fn super_fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + self.iter().map(|t| t.fold_with(folder)).collect() + } +} + +impl<T: PatternFoldable> PatternFoldable for Option<T> { + fn super_fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + self.as_ref().map(|t| t.fold_with(folder)) + } +} + +macro_rules! clone_impls { + ($($ty:ty),+) => { + $( + impl PatternFoldable for $ty { + fn super_fold_with<F: PatternFolder>(&self, _: &mut F) -> Self { + Clone::clone(self) + } + } + )+ + } +} + +clone_impls! { LocalFieldId, Ty, Substitution, EnumVariantId } + +impl PatternFoldable for FieldPat { + fn super_fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + FieldPat { field: self.field.fold_with(folder), pattern: self.pattern.fold_with(folder) } + } +} + +impl PatternFoldable for Pat { + fn fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + folder.fold_pattern(self) + } + + fn super_fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + Pat { ty: self.ty.fold_with(folder), kind: self.kind.fold_with(folder) } + } +} + +impl PatternFoldable for PatKind { + fn fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + folder.fold_pattern_kind(self) + } + + fn super_fold_with<F: PatternFolder>(&self, folder: &mut F) -> Self { + match self { + PatKind::Wild => PatKind::Wild, + PatKind::Binding { name, subpattern } => { + PatKind::Binding { name: name.clone(), subpattern: subpattern.fold_with(folder) } + } + PatKind::Variant { substs, enum_variant, subpatterns } => PatKind::Variant { + substs: substs.fold_with(folder), + enum_variant: enum_variant.fold_with(folder), + subpatterns: subpatterns.fold_with(folder), + }, + PatKind::Leaf { subpatterns } => { + PatKind::Leaf { subpatterns: subpatterns.fold_with(folder) } + } + PatKind::Deref { subpattern } => { + PatKind::Deref { subpattern: subpattern.fold_with(folder) } + } + &PatKind::LiteralBool { value } => PatKind::LiteralBool { value }, + PatKind::Or { pats } => PatKind::Or { pats: pats.fold_with(folder) }, + } + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs new file mode 100644 index 000000000..bbbe539c1 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs @@ -0,0 +1,1094 @@ +//! [`super::usefulness`] explains most of what is happening in this file. As explained there, +//! values and patterns are made from constructors applied to fields. This file defines a +//! `Constructor` enum, a `Fields` struct, and various operations to manipulate them and convert +//! them from/to patterns. +//! +//! There's one idea that is not detailed in [`super::usefulness`] because the details are not +//! needed there: _constructor splitting_. +//! +//! # Constructor splitting +//! +//! The idea is as follows: given a constructor `c` and a matrix, we want to specialize in turn +//! with all the value constructors that are covered by `c`, and compute usefulness for each. +//! Instead of listing all those constructors (which is intractable), we group those value +//! constructors together as much as possible. Example: +//! +//! ``` +//! match (0, false) { +//! (0 ..=100, true) => {} // `p_1` +//! (50..=150, false) => {} // `p_2` +//! (0 ..=200, _) => {} // `q` +//! } +//! ``` +//! +//! The naive approach would try all numbers in the range `0..=200`. But we can be a lot more +//! clever: `0` and `1` for example will match the exact same rows, and return equivalent +//! witnesses. In fact all of `0..50` would. We can thus restrict our exploration to 4 +//! constructors: `0..50`, `50..=100`, `101..=150` and `151..=200`. That is enough and infinitely +//! more tractable. +//! +//! We capture this idea in a function `split(p_1 ... p_n, c)` which returns a list of constructors +//! `c'` covered by `c`. Given such a `c'`, we require that all value ctors `c''` covered by `c'` +//! return an equivalent set of witnesses after specializing and computing usefulness. +//! In the example above, witnesses for specializing by `c''` covered by `0..50` will only differ +//! in their first element. +//! +//! We usually also ask that the `c'` together cover all of the original `c`. However we allow +//! skipping some constructors as long as it doesn't change whether the resulting list of witnesses +//! is empty of not. We use this in the wildcard `_` case. +//! +//! Splitting is implemented in the [`Constructor::split`] function. We don't do splitting for +//! or-patterns; instead we just try the alternatives one-by-one. For details on splitting +//! wildcards, see [`SplitWildcard`]; for integer ranges, see [`SplitIntRange`]. + +use std::{ + cell::Cell, + cmp::{max, min}, + iter::once, + ops::RangeInclusive, +}; + +use hir_def::{EnumVariantId, HasModule, LocalFieldId, VariantId}; +use smallvec::{smallvec, SmallVec}; +use stdx::never; + +use crate::{infer::normalize, AdtId, Interner, Scalar, Ty, TyExt, TyKind}; + +use super::{ + is_box, + usefulness::{helper::Captures, MatchCheckCtx, PatCtxt}, + FieldPat, Pat, PatKind, +}; + +use self::Constructor::*; + +/// Recursively expand this pattern into its subpatterns. Only useful for or-patterns. +fn expand_or_pat(pat: &Pat) -> Vec<&Pat> { + fn expand<'p>(pat: &'p Pat, vec: &mut Vec<&'p Pat>) { + if let PatKind::Or { pats } = pat.kind.as_ref() { + for pat in pats { + expand(pat, vec); + } + } else { + vec.push(pat) + } + } + + let mut pats = Vec::new(); + expand(pat, &mut pats); + pats +} + +/// [Constructor] uses this in umimplemented variants. +/// It allows porting match expressions from upstream algorithm without losing semantics. +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub(super) enum Void {} + +/// An inclusive interval, used for precise integer exhaustiveness checking. +/// `IntRange`s always store a contiguous range. This means that values are +/// encoded such that `0` encodes the minimum value for the integer, +/// regardless of the signedness. +/// For example, the pattern `-128..=127i8` is encoded as `0..=255`. +/// This makes comparisons and arithmetic on interval endpoints much more +/// straightforward. See `signed_bias` for details. +/// +/// `IntRange` is never used to encode an empty range or a "range" that wraps +/// around the (offset) space: i.e., `range.lo <= range.hi`. +#[derive(Clone, Debug, PartialEq, Eq)] +pub(super) struct IntRange { + range: RangeInclusive<u128>, +} + +impl IntRange { + #[inline] + fn is_integral(ty: &Ty) -> bool { + matches!( + ty.kind(Interner), + TyKind::Scalar(Scalar::Char | Scalar::Int(_) | Scalar::Uint(_) | Scalar::Bool) + ) + } + + fn is_singleton(&self) -> bool { + self.range.start() == self.range.end() + } + + fn boundaries(&self) -> (u128, u128) { + (*self.range.start(), *self.range.end()) + } + + #[inline] + fn from_bool(value: bool) -> IntRange { + let val = value as u128; + IntRange { range: val..=val } + } + + #[inline] + fn from_range(lo: u128, hi: u128, scalar_ty: Scalar) -> IntRange { + match scalar_ty { + Scalar::Bool => IntRange { range: lo..=hi }, + _ => unimplemented!(), + } + } + + fn is_subrange(&self, other: &Self) -> bool { + other.range.start() <= self.range.start() && self.range.end() <= other.range.end() + } + + fn intersection(&self, other: &Self) -> Option<Self> { + let (lo, hi) = self.boundaries(); + let (other_lo, other_hi) = other.boundaries(); + if lo <= other_hi && other_lo <= hi { + Some(IntRange { range: max(lo, other_lo)..=min(hi, other_hi) }) + } else { + None + } + } + + fn to_pat(&self, _cx: &MatchCheckCtx<'_, '_>, ty: Ty) -> Pat { + match ty.kind(Interner) { + TyKind::Scalar(Scalar::Bool) => { + let kind = match self.boundaries() { + (0, 0) => PatKind::LiteralBool { value: false }, + (1, 1) => PatKind::LiteralBool { value: true }, + (0, 1) => PatKind::Wild, + (lo, hi) => { + never!("bad range for bool pattern: {}..={}", lo, hi); + PatKind::Wild + } + }; + Pat { ty, kind: kind.into() } + } + _ => unimplemented!(), + } + } + + /// See `Constructor::is_covered_by` + fn is_covered_by(&self, other: &Self) -> bool { + if self.intersection(other).is_some() { + // Constructor splitting should ensure that all intersections we encounter are actually + // inclusions. + assert!(self.is_subrange(other)); + true + } else { + false + } + } +} + +/// Represents a border between 2 integers. Because the intervals spanning borders must be able to +/// cover every integer, we need to be able to represent 2^128 + 1 such borders. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +enum IntBorder { + JustBefore(u128), + AfterMax, +} + +/// A range of integers that is partitioned into disjoint subranges. This does constructor +/// splitting for integer ranges as explained at the top of the file. +/// +/// This is fed multiple ranges, and returns an output that covers the input, but is split so that +/// the only intersections between an output range and a seen range are inclusions. No output range +/// straddles the boundary of one of the inputs. +/// +/// The following input: +/// ``` +/// |-------------------------| // `self` +/// |------| |----------| |----| +/// |-------| |-------| +/// ``` +/// would be iterated over as follows: +/// ``` +/// ||---|--||-|---|---|---|--| +/// ``` +#[derive(Debug, Clone)] +struct SplitIntRange { + /// The range we are splitting + range: IntRange, + /// The borders of ranges we have seen. They are all contained within `range`. This is kept + /// sorted. + borders: Vec<IntBorder>, +} + +impl SplitIntRange { + fn new(range: IntRange) -> Self { + SplitIntRange { range, borders: Vec::new() } + } + + /// Internal use + fn to_borders(r: IntRange) -> [IntBorder; 2] { + use IntBorder::*; + let (lo, hi) = r.boundaries(); + let lo = JustBefore(lo); + let hi = match hi.checked_add(1) { + Some(m) => JustBefore(m), + None => AfterMax, + }; + [lo, hi] + } + + /// Add ranges relative to which we split. + fn split(&mut self, ranges: impl Iterator<Item = IntRange>) { + let this_range = &self.range; + let included_ranges = ranges.filter_map(|r| this_range.intersection(&r)); + let included_borders = included_ranges.flat_map(|r| { + let borders = Self::to_borders(r); + once(borders[0]).chain(once(borders[1])) + }); + self.borders.extend(included_borders); + self.borders.sort_unstable(); + } + + /// Iterate over the contained ranges. + fn iter(&self) -> impl Iterator<Item = IntRange> + '_ { + use IntBorder::*; + + let self_range = Self::to_borders(self.range.clone()); + // Start with the start of the range. + let mut prev_border = self_range[0]; + self.borders + .iter() + .copied() + // End with the end of the range. + .chain(once(self_range[1])) + // List pairs of adjacent borders. + .map(move |border| { + let ret = (prev_border, border); + prev_border = border; + ret + }) + // Skip duplicates. + .filter(|(prev_border, border)| prev_border != border) + // Finally, convert to ranges. + .map(|(prev_border, border)| { + let range = match (prev_border, border) { + (JustBefore(n), JustBefore(m)) if n < m => n..=(m - 1), + (JustBefore(n), AfterMax) => n..=u128::MAX, + _ => unreachable!(), // Ruled out by the sorting and filtering we did + }; + IntRange { range } + }) + } +} + +/// A constructor for array and slice patterns. +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub(super) struct Slice { + _unimplemented: Void, +} + +impl Slice { + fn arity(self) -> usize { + match self._unimplemented {} + } + + /// See `Constructor::is_covered_by` + fn is_covered_by(self, _other: Self) -> bool { + match self._unimplemented {} + } +} + +/// A value can be decomposed into a constructor applied to some fields. This struct represents +/// the constructor. See also `Fields`. +/// +/// `pat_constructor` retrieves the constructor corresponding to a pattern. +/// `specialize_constructor` returns the list of fields corresponding to a pattern, given a +/// constructor. `Constructor::apply` reconstructs the pattern from a pair of `Constructor` and +/// `Fields`. +#[allow(dead_code)] +#[derive(Clone, Debug, PartialEq)] +pub(super) enum Constructor { + /// The constructor for patterns that have a single constructor, like tuples, struct patterns + /// and fixed-length arrays. + Single, + /// Enum variants. + Variant(EnumVariantId), + /// Ranges of integer literal values (`2`, `2..=5` or `2..5`). + IntRange(IntRange), + /// Ranges of floating-point literal values (`2.0..=5.2`). + FloatRange(Void), + /// String literals. Strings are not quite the same as `&[u8]` so we treat them separately. + Str(Void), + /// Array and slice patterns. + Slice(Slice), + /// Constants that must not be matched structurally. They are treated as black + /// boxes for the purposes of exhaustiveness: we must not inspect them, and they + /// don't count towards making a match exhaustive. + Opaque, + /// Fake extra constructor for enums that aren't allowed to be matched exhaustively. Also used + /// for those types for which we cannot list constructors explicitly, like `f64` and `str`. + NonExhaustive, + /// Stands for constructors that are not seen in the matrix, as explained in the documentation + /// for [`SplitWildcard`]. The carried `bool` is used for the `non_exhaustive_omitted_patterns` + /// lint. + Missing { nonexhaustive_enum_missing_real_variants: bool }, + /// Wildcard pattern. + Wildcard, + /// Or-pattern. + Or, +} + +impl Constructor { + pub(super) fn is_wildcard(&self) -> bool { + matches!(self, Wildcard) + } + + pub(super) fn is_non_exhaustive(&self) -> bool { + matches!(self, NonExhaustive) + } + + fn as_int_range(&self) -> Option<&IntRange> { + match self { + IntRange(range) => Some(range), + _ => None, + } + } + + fn as_slice(&self) -> Option<Slice> { + match self { + Slice(slice) => Some(*slice), + _ => None, + } + } + + pub(super) fn is_unstable_variant(&self, _pcx: PatCtxt<'_, '_>) -> bool { + false //FIXME: implement this + } + + pub(super) fn is_doc_hidden_variant(&self, _pcx: PatCtxt<'_, '_>) -> bool { + false //FIXME: implement this + } + + fn variant_id_for_adt(&self, adt: hir_def::AdtId) -> VariantId { + match *self { + Variant(id) => id.into(), + Single => { + assert!(!matches!(adt, hir_def::AdtId::EnumId(_))); + match adt { + hir_def::AdtId::EnumId(_) => unreachable!(), + hir_def::AdtId::StructId(id) => id.into(), + hir_def::AdtId::UnionId(id) => id.into(), + } + } + _ => panic!("bad constructor {:?} for adt {:?}", self, adt), + } + } + + /// The number of fields for this constructor. This must be kept in sync with + /// `Fields::wildcards`. + pub(super) fn arity(&self, pcx: PatCtxt<'_, '_>) -> usize { + match self { + Single | Variant(_) => match *pcx.ty.kind(Interner) { + TyKind::Tuple(arity, ..) => arity, + TyKind::Ref(..) => 1, + TyKind::Adt(adt, ..) => { + if is_box(adt.0, pcx.cx.db) { + // The only legal patterns of type `Box` (outside `std`) are `_` and box + // patterns. If we're here we can assume this is a box pattern. + 1 + } else { + let variant = self.variant_id_for_adt(adt.0); + Fields::list_variant_nonhidden_fields(pcx.cx, pcx.ty, variant).count() + } + } + _ => { + never!("Unexpected type for `Single` constructor: {:?}", pcx.ty); + 0 + } + }, + Slice(slice) => slice.arity(), + Str(..) + | FloatRange(..) + | IntRange(..) + | NonExhaustive + | Opaque + | Missing { .. } + | Wildcard => 0, + Or => { + never!("The `Or` constructor doesn't have a fixed arity"); + 0 + } + } + } + + /// Some constructors (namely `Wildcard`, `IntRange` and `Slice`) actually stand for a set of actual + /// constructors (like variants, integers or fixed-sized slices). When specializing for these + /// constructors, we want to be specialising for the actual underlying constructors. + /// Naively, we would simply return the list of constructors they correspond to. We instead are + /// more clever: if there are constructors that we know will behave the same wrt the current + /// matrix, we keep them grouped. For example, all slices of a sufficiently large length + /// will either be all useful or all non-useful with a given matrix. + /// + /// See the branches for details on how the splitting is done. + /// + /// This function may discard some irrelevant constructors if this preserves behavior and + /// diagnostics. Eg. for the `_` case, we ignore the constructors already present in the + /// matrix, unless all of them are. + pub(super) fn split<'a>( + &self, + pcx: PatCtxt<'_, '_>, + ctors: impl Iterator<Item = &'a Constructor> + Clone, + ) -> SmallVec<[Self; 1]> { + match self { + Wildcard => { + let mut split_wildcard = SplitWildcard::new(pcx); + split_wildcard.split(pcx, ctors); + split_wildcard.into_ctors(pcx) + } + // Fast-track if the range is trivial. In particular, we don't do the overlapping + // ranges check. + IntRange(ctor_range) if !ctor_range.is_singleton() => { + let mut split_range = SplitIntRange::new(ctor_range.clone()); + let int_ranges = ctors.filter_map(|ctor| ctor.as_int_range()); + split_range.split(int_ranges.cloned()); + split_range.iter().map(IntRange).collect() + } + Slice(slice) => match slice._unimplemented {}, + // Any other constructor can be used unchanged. + _ => smallvec![self.clone()], + } + } + + /// Returns whether `self` is covered by `other`, i.e. whether `self` is a subset of `other`. + /// For the simple cases, this is simply checking for equality. For the "grouped" constructors, + /// this checks for inclusion. + // We inline because this has a single call site in `Matrix::specialize_constructor`. + #[inline] + pub(super) fn is_covered_by(&self, _pcx: PatCtxt<'_, '_>, other: &Self) -> bool { + // This must be kept in sync with `is_covered_by_any`. + match (self, other) { + // Wildcards cover anything + (_, Wildcard) => true, + // The missing ctors are not covered by anything in the matrix except wildcards. + (Missing { .. } | Wildcard, _) => false, + + (Single, Single) => true, + (Variant(self_id), Variant(other_id)) => self_id == other_id, + + (IntRange(self_range), IntRange(other_range)) => self_range.is_covered_by(other_range), + (FloatRange(void), FloatRange(..)) => match *void {}, + (Str(void), Str(..)) => match *void {}, + (Slice(self_slice), Slice(other_slice)) => self_slice.is_covered_by(*other_slice), + + // We are trying to inspect an opaque constant. Thus we skip the row. + (Opaque, _) | (_, Opaque) => false, + // Only a wildcard pattern can match the special extra constructor. + (NonExhaustive, _) => false, + + _ => { + never!("trying to compare incompatible constructors {:?} and {:?}", self, other); + // Continue with 'whatever is covered' supposed to result in false no-error diagnostic. + true + } + } + } + + /// Faster version of `is_covered_by` when applied to many constructors. `used_ctors` is + /// assumed to be built from `matrix.head_ctors()` with wildcards filtered out, and `self` is + /// assumed to have been split from a wildcard. + fn is_covered_by_any(&self, _pcx: PatCtxt<'_, '_>, used_ctors: &[Constructor]) -> bool { + if used_ctors.is_empty() { + return false; + } + + // This must be kept in sync with `is_covered_by`. + match self { + // If `self` is `Single`, `used_ctors` cannot contain anything else than `Single`s. + Single => !used_ctors.is_empty(), + Variant(_) => used_ctors.iter().any(|c| c == self), + IntRange(range) => used_ctors + .iter() + .filter_map(|c| c.as_int_range()) + .any(|other| range.is_covered_by(other)), + Slice(slice) => used_ctors + .iter() + .filter_map(|c| c.as_slice()) + .any(|other| slice.is_covered_by(other)), + // This constructor is never covered by anything else + NonExhaustive => false, + Str(..) | FloatRange(..) | Opaque | Missing { .. } | Wildcard | Or => { + never!("found unexpected ctor in all_ctors: {:?}", self); + true + } + } + } +} + +/// A wildcard constructor that we split relative to the constructors in the matrix, as explained +/// at the top of the file. +/// +/// A constructor that is not present in the matrix rows will only be covered by the rows that have +/// wildcards. Thus we can group all of those constructors together; we call them "missing +/// constructors". Splitting a wildcard would therefore list all present constructors individually +/// (or grouped if they are integers or slices), and then all missing constructors together as a +/// group. +/// +/// However we can go further: since any constructor will match the wildcard rows, and having more +/// rows can only reduce the amount of usefulness witnesses, we can skip the present constructors +/// and only try the missing ones. +/// This will not preserve the whole list of witnesses, but will preserve whether the list is empty +/// or not. In fact this is quite natural from the point of view of diagnostics too. This is done +/// in `to_ctors`: in some cases we only return `Missing`. +#[derive(Debug)] +pub(super) struct SplitWildcard { + /// Constructors seen in the matrix. + matrix_ctors: Vec<Constructor>, + /// All the constructors for this type + all_ctors: SmallVec<[Constructor; 1]>, +} + +impl SplitWildcard { + pub(super) fn new(pcx: PatCtxt<'_, '_>) -> Self { + let cx = pcx.cx; + let make_range = |start, end, scalar| IntRange(IntRange::from_range(start, end, scalar)); + + // Unhandled types are treated as non-exhaustive. Being explicit here instead of falling + // to catchall arm to ease further implementation. + let unhandled = || smallvec![NonExhaustive]; + + // This determines the set of all possible constructors for the type `pcx.ty`. For numbers, + // arrays and slices we use ranges and variable-length slices when appropriate. + // + // If the `exhaustive_patterns` feature is enabled, we make sure to omit constructors that + // are statically impossible. E.g., for `Option<!>`, we do not include `Some(_)` in the + // returned list of constructors. + // Invariant: this is empty if and only if the type is uninhabited (as determined by + // `cx.is_uninhabited()`). + let all_ctors = match pcx.ty.kind(Interner) { + TyKind::Scalar(Scalar::Bool) => smallvec![make_range(0, 1, Scalar::Bool)], + // TyKind::Array(..) if ... => unhandled(), + TyKind::Array(..) | TyKind::Slice(..) => unhandled(), + &TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), ..) => { + let enum_data = cx.db.enum_data(enum_id); + + // If the enum is declared as `#[non_exhaustive]`, we treat it as if it had an + // additional "unknown" constructor. + // There is no point in enumerating all possible variants, because the user can't + // actually match against them all themselves. So we always return only the fictitious + // constructor. + // E.g., in an example like: + // + // ``` + // let err: io::ErrorKind = ...; + // match err { + // io::ErrorKind::NotFound => {}, + // } + // ``` + // + // we don't want to show every possible IO error, but instead have only `_` as the + // witness. + let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive_enum(pcx.ty); + + let is_exhaustive_pat_feature = cx.feature_exhaustive_patterns(); + + // If `exhaustive_patterns` is disabled and our scrutinee is an empty enum, we treat it + // as though it had an "unknown" constructor to avoid exposing its emptiness. The + // exception is if the pattern is at the top level, because we want empty matches to be + // considered exhaustive. + let is_secretly_empty = enum_data.variants.is_empty() + && !is_exhaustive_pat_feature + && !pcx.is_top_level; + + let mut ctors: SmallVec<[_; 1]> = enum_data + .variants + .iter() + .filter(|&(_, _v)| { + // If `exhaustive_patterns` is enabled, we exclude variants known to be + // uninhabited. + let is_uninhabited = is_exhaustive_pat_feature + && unimplemented!("after MatchCheckCtx.feature_exhaustive_patterns()"); + !is_uninhabited + }) + .map(|(local_id, _)| Variant(EnumVariantId { parent: enum_id, local_id })) + .collect(); + + if is_secretly_empty || is_declared_nonexhaustive { + ctors.push(NonExhaustive); + } + ctors + } + TyKind::Scalar(Scalar::Char) => unhandled(), + TyKind::Scalar(Scalar::Int(..) | Scalar::Uint(..)) => unhandled(), + TyKind::Never if !cx.feature_exhaustive_patterns() && !pcx.is_top_level => { + smallvec![NonExhaustive] + } + TyKind::Never => SmallVec::new(), + _ if cx.is_uninhabited(pcx.ty) => SmallVec::new(), + TyKind::Adt(..) | TyKind::Tuple(..) | TyKind::Ref(..) => smallvec![Single], + // This type is one for which we cannot list constructors, like `str` or `f64`. + _ => smallvec![NonExhaustive], + }; + + SplitWildcard { matrix_ctors: Vec::new(), all_ctors } + } + + /// Pass a set of constructors relative to which to split this one. Don't call twice, it won't + /// do what you want. + pub(super) fn split<'a>( + &mut self, + pcx: PatCtxt<'_, '_>, + ctors: impl Iterator<Item = &'a Constructor> + Clone, + ) { + // Since `all_ctors` never contains wildcards, this won't recurse further. + self.all_ctors = + self.all_ctors.iter().flat_map(|ctor| ctor.split(pcx, ctors.clone())).collect(); + self.matrix_ctors = ctors.filter(|c| !c.is_wildcard()).cloned().collect(); + } + + /// Whether there are any value constructors for this type that are not present in the matrix. + fn any_missing(&self, pcx: PatCtxt<'_, '_>) -> bool { + self.iter_missing(pcx).next().is_some() + } + + /// Iterate over the constructors for this type that are not present in the matrix. + pub(super) fn iter_missing<'a, 'p>( + &'a self, + pcx: PatCtxt<'a, 'p>, + ) -> impl Iterator<Item = &'a Constructor> + Captures<'p> { + self.all_ctors.iter().filter(move |ctor| !ctor.is_covered_by_any(pcx, &self.matrix_ctors)) + } + + /// Return the set of constructors resulting from splitting the wildcard. As explained at the + /// top of the file, if any constructors are missing we can ignore the present ones. + fn into_ctors(self, pcx: PatCtxt<'_, '_>) -> SmallVec<[Constructor; 1]> { + if self.any_missing(pcx) { + // Some constructors are missing, thus we can specialize with the special `Missing` + // constructor, which stands for those constructors that are not seen in the matrix, + // and matches the same rows as any of them (namely the wildcard rows). See the top of + // the file for details. + // However, when all constructors are missing we can also specialize with the full + // `Wildcard` constructor. The difference will depend on what we want in diagnostics. + + // If some constructors are missing, we typically want to report those constructors, + // e.g.: + // ``` + // enum Direction { N, S, E, W } + // let Direction::N = ...; + // ``` + // we can report 3 witnesses: `S`, `E`, and `W`. + // + // However, if the user didn't actually specify a constructor + // in this arm, e.g., in + // ``` + // let x: (Direction, Direction, bool) = ...; + // let (_, _, false) = x; + // ``` + // we don't want to show all 16 possible witnesses `(<direction-1>, <direction-2>, + // true)` - we are satisfied with `(_, _, true)`. So if all constructors are missing we + // prefer to report just a wildcard `_`. + // + // The exception is: if we are at the top-level, for example in an empty match, we + // sometimes prefer reporting the list of constructors instead of just `_`. + let report_when_all_missing = pcx.is_top_level && !IntRange::is_integral(pcx.ty); + let ctor = if !self.matrix_ctors.is_empty() || report_when_all_missing { + if pcx.is_non_exhaustive { + Missing { + nonexhaustive_enum_missing_real_variants: self + .iter_missing(pcx) + .any(|c| !(c.is_non_exhaustive() || c.is_unstable_variant(pcx))), + } + } else { + Missing { nonexhaustive_enum_missing_real_variants: false } + } + } else { + Wildcard + }; + return smallvec![ctor]; + } + + // All the constructors are present in the matrix, so we just go through them all. + self.all_ctors + } +} + +/// A value can be decomposed into a constructor applied to some fields. This struct represents +/// those fields, generalized to allow patterns in each field. See also `Constructor`. +/// +/// This is constructed for a constructor using [`Fields::wildcards()`]. The idea is that +/// [`Fields::wildcards()`] constructs a list of fields where all entries are wildcards, and then +/// given a pattern we fill some of the fields with its subpatterns. +/// In the following example `Fields::wildcards` returns `[_, _, _, _]`. Then in +/// `extract_pattern_arguments` we fill some of the entries, and the result is +/// `[Some(0), _, _, _]`. +/// ```rust +/// let x: [Option<u8>; 4] = foo(); +/// match x { +/// [Some(0), ..] => {} +/// } +/// ``` +/// +/// Note that the number of fields of a constructor may not match the fields declared in the +/// original struct/variant. This happens if a private or `non_exhaustive` field is uninhabited, +/// because the code mustn't observe that it is uninhabited. In that case that field is not +/// included in `fields`. For that reason, when you have a `mir::Field` you must use +/// `index_with_declared_idx`. +#[derive(Clone, Copy)] +pub(super) struct Fields<'p> { + fields: &'p [DeconstructedPat<'p>], +} + +impl<'p> Fields<'p> { + fn empty() -> Self { + Fields { fields: &[] } + } + + fn singleton(cx: &MatchCheckCtx<'_, 'p>, field: DeconstructedPat<'p>) -> Self { + let field = cx.pattern_arena.alloc(field); + Fields { fields: std::slice::from_ref(field) } + } + + pub(super) fn from_iter( + cx: &MatchCheckCtx<'_, 'p>, + fields: impl IntoIterator<Item = DeconstructedPat<'p>>, + ) -> Self { + let fields: &[_] = cx.pattern_arena.alloc_extend(fields); + Fields { fields } + } + + fn wildcards_from_tys(cx: &MatchCheckCtx<'_, 'p>, tys: impl IntoIterator<Item = Ty>) -> Self { + Fields::from_iter(cx, tys.into_iter().map(DeconstructedPat::wildcard)) + } + + // In the cases of either a `#[non_exhaustive]` field list or a non-public field, we hide + // uninhabited fields in order not to reveal the uninhabitedness of the whole variant. + // This lists the fields we keep along with their types. + fn list_variant_nonhidden_fields<'a>( + cx: &'a MatchCheckCtx<'a, 'p>, + ty: &'a Ty, + variant: VariantId, + ) -> impl Iterator<Item = (LocalFieldId, Ty)> + Captures<'a> + Captures<'p> { + let (adt, substs) = ty.as_adt().unwrap(); + + let adt_is_local = variant.module(cx.db.upcast()).krate() == cx.module.krate(); + // Whether we must not match the fields of this variant exhaustively. + let is_non_exhaustive = is_field_list_non_exhaustive(variant, cx) && !adt_is_local; + + let visibility = cx.db.field_visibilities(variant); + let field_ty = cx.db.field_types(variant); + let fields_len = variant.variant_data(cx.db.upcast()).fields().len() as u32; + + (0..fields_len).map(|idx| LocalFieldId::from_raw(idx.into())).filter_map(move |fid| { + let ty = field_ty[fid].clone().substitute(Interner, substs); + let ty = normalize(cx.db, cx.body, ty); + let is_visible = matches!(adt, hir_def::AdtId::EnumId(..)) + || visibility[fid].is_visible_from(cx.db.upcast(), cx.module); + let is_uninhabited = cx.is_uninhabited(&ty); + + if is_uninhabited && (!is_visible || is_non_exhaustive) { + None + } else { + Some((fid, ty)) + } + }) + } + + /// Creates a new list of wildcard fields for a given constructor. The result must have a + /// length of `constructor.arity()`. + pub(crate) fn wildcards( + cx: &MatchCheckCtx<'_, 'p>, + ty: &Ty, + constructor: &Constructor, + ) -> Self { + let ret = match constructor { + Single | Variant(_) => match ty.kind(Interner) { + TyKind::Tuple(_, substs) => { + let tys = substs.iter(Interner).map(|ty| ty.assert_ty_ref(Interner)); + Fields::wildcards_from_tys(cx, tys.cloned()) + } + TyKind::Ref(.., rty) => Fields::wildcards_from_tys(cx, once(rty.clone())), + &TyKind::Adt(AdtId(adt), ref substs) => { + if is_box(adt, cx.db) { + // The only legal patterns of type `Box` (outside `std`) are `_` and box + // patterns. If we're here we can assume this is a box pattern. + let subst_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone(); + Fields::wildcards_from_tys(cx, once(subst_ty)) + } else { + let variant = constructor.variant_id_for_adt(adt); + let tys = Fields::list_variant_nonhidden_fields(cx, ty, variant) + .map(|(_, ty)| ty); + Fields::wildcards_from_tys(cx, tys) + } + } + ty_kind => { + never!("Unexpected type for `Single` constructor: {:?}", ty_kind); + Fields::wildcards_from_tys(cx, once(ty.clone())) + } + }, + Slice(slice) => match slice._unimplemented {}, + Str(..) + | FloatRange(..) + | IntRange(..) + | NonExhaustive + | Opaque + | Missing { .. } + | Wildcard => Fields::empty(), + Or => { + never!("called `Fields::wildcards` on an `Or` ctor"); + Fields::empty() + } + }; + ret + } + + /// Returns the list of patterns. + pub(super) fn iter_patterns<'a>( + &'a self, + ) -> impl Iterator<Item = &'p DeconstructedPat<'p>> + Captures<'a> { + self.fields.iter() + } +} + +/// Values and patterns can be represented as a constructor applied to some fields. This represents +/// a pattern in this form. +/// This also keeps track of whether the pattern has been found reachable during analysis. For this +/// reason we should be careful not to clone patterns for which we care about that. Use +/// `clone_and_forget_reachability` if you're sure. +pub(crate) struct DeconstructedPat<'p> { + ctor: Constructor, + fields: Fields<'p>, + ty: Ty, + reachable: Cell<bool>, +} + +impl<'p> DeconstructedPat<'p> { + pub(super) fn wildcard(ty: Ty) -> Self { + Self::new(Wildcard, Fields::empty(), ty) + } + + pub(super) fn new(ctor: Constructor, fields: Fields<'p>, ty: Ty) -> Self { + DeconstructedPat { ctor, fields, ty, reachable: Cell::new(false) } + } + + /// Construct a pattern that matches everything that starts with this constructor. + /// For example, if `ctor` is a `Constructor::Variant` for `Option::Some`, we get the pattern + /// `Some(_)`. + pub(super) fn wild_from_ctor(pcx: PatCtxt<'_, 'p>, ctor: Constructor) -> Self { + let fields = Fields::wildcards(pcx.cx, pcx.ty, &ctor); + DeconstructedPat::new(ctor, fields, pcx.ty.clone()) + } + + /// Clone this value. This method emphasizes that cloning loses reachability information and + /// should be done carefully. + pub(super) fn clone_and_forget_reachability(&self) -> Self { + DeconstructedPat::new(self.ctor.clone(), self.fields, self.ty.clone()) + } + + pub(crate) fn from_pat(cx: &MatchCheckCtx<'_, 'p>, pat: &Pat) -> Self { + let mkpat = |pat| DeconstructedPat::from_pat(cx, pat); + let ctor; + let fields; + match pat.kind.as_ref() { + PatKind::Binding { subpattern: Some(subpat), .. } => return mkpat(subpat), + PatKind::Binding { subpattern: None, .. } | PatKind::Wild => { + ctor = Wildcard; + fields = Fields::empty(); + } + PatKind::Deref { subpattern } => { + ctor = Single; + fields = Fields::singleton(cx, mkpat(subpattern)); + } + PatKind::Leaf { subpatterns } | PatKind::Variant { subpatterns, .. } => { + match pat.ty.kind(Interner) { + TyKind::Tuple(_, substs) => { + ctor = Single; + let mut wilds: SmallVec<[_; 2]> = substs + .iter(Interner) + .map(|arg| arg.assert_ty_ref(Interner).clone()) + .map(DeconstructedPat::wildcard) + .collect(); + for pat in subpatterns { + let idx: u32 = pat.field.into_raw().into(); + wilds[idx as usize] = mkpat(&pat.pattern); + } + fields = Fields::from_iter(cx, wilds) + } + TyKind::Adt(adt, substs) if is_box(adt.0, cx.db) => { + // The only legal patterns of type `Box` (outside `std`) are `_` and box + // patterns. If we're here we can assume this is a box pattern. + // FIXME(Nadrieril): A `Box` can in theory be matched either with `Box(_, + // _)` or a box pattern. As a hack to avoid an ICE with the former, we + // ignore other fields than the first one. This will trigger an error later + // anyway. + // See https://github.com/rust-lang/rust/issues/82772 , + // explanation: https://github.com/rust-lang/rust/pull/82789#issuecomment-796921977 + // The problem is that we can't know from the type whether we'll match + // normally or through box-patterns. We'll have to figure out a proper + // solution when we introduce generalized deref patterns. Also need to + // prevent mixing of those two options. + let pat = + subpatterns.iter().find(|pat| pat.field.into_raw() == 0u32.into()); + let field = if let Some(pat) = pat { + mkpat(&pat.pattern) + } else { + let ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone(); + DeconstructedPat::wildcard(ty) + }; + ctor = Single; + fields = Fields::singleton(cx, field) + } + &TyKind::Adt(adt, _) => { + ctor = match pat.kind.as_ref() { + PatKind::Leaf { .. } => Single, + PatKind::Variant { enum_variant, .. } => Variant(*enum_variant), + _ => { + never!(); + Wildcard + } + }; + let variant = ctor.variant_id_for_adt(adt.0); + let fields_len = variant.variant_data(cx.db.upcast()).fields().len(); + // For each field in the variant, we store the relevant index into `self.fields` if any. + let mut field_id_to_id: Vec<Option<usize>> = vec![None; fields_len]; + let tys = Fields::list_variant_nonhidden_fields(cx, &pat.ty, variant) + .enumerate() + .map(|(i, (fid, ty))| { + let field_idx: u32 = fid.into_raw().into(); + field_id_to_id[field_idx as usize] = Some(i); + ty + }); + let mut wilds: SmallVec<[_; 2]> = + tys.map(DeconstructedPat::wildcard).collect(); + for pat in subpatterns { + let field_idx: u32 = pat.field.into_raw().into(); + if let Some(i) = field_id_to_id[field_idx as usize] { + wilds[i] = mkpat(&pat.pattern); + } + } + fields = Fields::from_iter(cx, wilds); + } + _ => { + never!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, &pat.ty); + ctor = Wildcard; + fields = Fields::empty(); + } + } + } + &PatKind::LiteralBool { value } => { + ctor = IntRange(IntRange::from_bool(value)); + fields = Fields::empty(); + } + PatKind::Or { .. } => { + ctor = Or; + let pats: SmallVec<[_; 2]> = expand_or_pat(pat).into_iter().map(mkpat).collect(); + fields = Fields::from_iter(cx, pats) + } + } + DeconstructedPat::new(ctor, fields, pat.ty.clone()) + } + + pub(crate) fn to_pat(&self, cx: &MatchCheckCtx<'_, 'p>) -> Pat { + let mut subpatterns = self.iter_fields().map(|p| p.to_pat(cx)); + let pat = match &self.ctor { + Single | Variant(_) => match self.ty.kind(Interner) { + TyKind::Tuple(..) => PatKind::Leaf { + subpatterns: subpatterns + .zip(0u32..) + .map(|(p, i)| FieldPat { + field: LocalFieldId::from_raw(i.into()), + pattern: p, + }) + .collect(), + }, + TyKind::Adt(adt, _) if is_box(adt.0, cx.db) => { + // Without `box_patterns`, the only legal pattern of type `Box` is `_` (outside + // of `std`). So this branch is only reachable when the feature is enabled and + // the pattern is a box pattern. + PatKind::Deref { subpattern: subpatterns.next().unwrap() } + } + TyKind::Adt(adt, substs) => { + let variant = self.ctor.variant_id_for_adt(adt.0); + let subpatterns = Fields::list_variant_nonhidden_fields(cx, self.ty(), variant) + .zip(subpatterns) + .map(|((field, _ty), pattern)| FieldPat { field, pattern }) + .collect(); + + if let VariantId::EnumVariantId(enum_variant) = variant { + PatKind::Variant { substs: substs.clone(), enum_variant, subpatterns } + } else { + PatKind::Leaf { subpatterns } + } + } + // Note: given the expansion of `&str` patterns done in `expand_pattern`, we should + // be careful to reconstruct the correct constant pattern here. However a string + // literal pattern will never be reported as a non-exhaustiveness witness, so we + // ignore this issue. + TyKind::Ref(..) => PatKind::Deref { subpattern: subpatterns.next().unwrap() }, + _ => { + never!("unexpected ctor for type {:?} {:?}", self.ctor, self.ty); + PatKind::Wild + } + }, + &Slice(slice) => match slice._unimplemented {}, + &Str(void) => match void {}, + &FloatRange(void) => match void {}, + IntRange(range) => return range.to_pat(cx, self.ty.clone()), + Wildcard | NonExhaustive => PatKind::Wild, + Missing { .. } => { + never!( + "trying to convert a `Missing` constructor into a `Pat`; this is a bug, \ + `Missing` should have been processed in `apply_constructors`" + ); + PatKind::Wild + } + Opaque | Or => { + never!("can't convert to pattern: {:?}", self.ctor); + PatKind::Wild + } + }; + Pat { ty: self.ty.clone(), kind: Box::new(pat) } + } + + pub(super) fn is_or_pat(&self) -> bool { + matches!(self.ctor, Or) + } + + pub(super) fn ctor(&self) -> &Constructor { + &self.ctor + } + + pub(super) fn ty(&self) -> &Ty { + &self.ty + } + + pub(super) fn iter_fields<'a>(&'a self) -> impl Iterator<Item = &'p DeconstructedPat<'p>> + 'a { + self.fields.iter_patterns() + } + + /// Specialize this pattern with a constructor. + /// `other_ctor` can be different from `self.ctor`, but must be covered by it. + pub(super) fn specialize<'a>( + &'a self, + cx: &MatchCheckCtx<'_, 'p>, + other_ctor: &Constructor, + ) -> SmallVec<[&'p DeconstructedPat<'p>; 2]> { + match (&self.ctor, other_ctor) { + (Wildcard, _) => { + // We return a wildcard for each field of `other_ctor`. + Fields::wildcards(cx, &self.ty, other_ctor).iter_patterns().collect() + } + (Slice(self_slice), Slice(other_slice)) + if self_slice.arity() != other_slice.arity() => + { + match self_slice._unimplemented {} + } + _ => self.fields.iter_patterns().collect(), + } + } + + /// We keep track for each pattern if it was ever reachable during the analysis. This is used + /// with `unreachable_spans` to report unreachable subpatterns arising from or patterns. + pub(super) fn set_reachable(&self) { + self.reachable.set(true) + } + pub(super) fn is_reachable(&self) -> bool { + self.reachable.get() + } +} + +fn is_field_list_non_exhaustive(variant_id: VariantId, cx: &MatchCheckCtx<'_, '_>) -> bool { + let attr_def_id = match variant_id { + VariantId::EnumVariantId(id) => id.into(), + VariantId::StructId(id) => id.into(), + VariantId::UnionId(id) => id.into(), + }; + cx.db.attrs(attr_def_id).by_key("non_exhaustive").exists() +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_util.rs new file mode 100644 index 000000000..b89b4f2bf --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_util.rs @@ -0,0 +1,56 @@ +//! Pattern untilities. +//! +//! Originates from `rustc_hir::pat_util` + +use std::iter::{Enumerate, ExactSizeIterator}; + +pub(crate) struct EnumerateAndAdjust<I> { + enumerate: Enumerate<I>, + gap_pos: usize, + gap_len: usize, +} + +impl<I> Iterator for EnumerateAndAdjust<I> +where + I: Iterator, +{ + type Item = (usize, <I as Iterator>::Item); + + fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)> { + self.enumerate + .next() + .map(|(i, elem)| (if i < self.gap_pos { i } else { i + self.gap_len }, elem)) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + self.enumerate.size_hint() + } +} + +pub(crate) trait EnumerateAndAdjustIterator { + fn enumerate_and_adjust( + self, + expected_len: usize, + gap_pos: Option<usize>, + ) -> EnumerateAndAdjust<Self> + where + Self: Sized; +} + +impl<T: ExactSizeIterator> EnumerateAndAdjustIterator for T { + fn enumerate_and_adjust( + self, + expected_len: usize, + gap_pos: Option<usize>, + ) -> EnumerateAndAdjust<Self> + where + Self: Sized, + { + let actual_len = self.len(); + EnumerateAndAdjust { + enumerate: self.enumerate(), + gap_pos: gap_pos.unwrap_or(expected_len), + gap_len: expected_len - actual_len, + } + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/usefulness.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/usefulness.rs new file mode 100644 index 000000000..1221327b9 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/usefulness.rs @@ -0,0 +1,811 @@ +//! Based on rust-lang/rust (last sync f31622a50 2021-11-12) +//! <https://github.com/rust-lang/rust/blob/f31622a50/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs> +//! +//! ----- +//! +//! This file includes the logic for exhaustiveness and reachability checking for pattern-matching. +//! Specifically, given a list of patterns for a type, we can tell whether: +//! (a) each pattern is reachable (reachability) +//! (b) the patterns cover every possible value for the type (exhaustiveness) +//! +//! The algorithm implemented here is a modified version of the one described in [this +//! paper](http://moscova.inria.fr/~maranget/papers/warn/index.html). We have however generalized +//! it to accommodate the variety of patterns that Rust supports. We thus explain our version here, +//! without being as rigorous. +//! +//! +//! # Summary +//! +//! The core of the algorithm is the notion of "usefulness". A pattern `q` is said to be *useful* +//! relative to another pattern `p` of the same type if there is a value that is matched by `q` and +//! not matched by `p`. This generalizes to many `p`s: `q` is useful w.r.t. a list of patterns +//! `p_1 .. p_n` if there is a value that is matched by `q` and by none of the `p_i`. We write +//! `usefulness(p_1 .. p_n, q)` for a function that returns a list of such values. The aim of this +//! file is to compute it efficiently. +//! +//! This is enough to compute reachability: a pattern in a `match` expression is reachable iff it +//! is useful w.r.t. the patterns above it: +//! ```rust +//! match x { +//! Some(_) => ..., +//! None => ..., // reachable: `None` is matched by this but not the branch above +//! Some(0) => ..., // unreachable: all the values this matches are already matched by +//! // `Some(_)` above +//! } +//! ``` +//! +//! This is also enough to compute exhaustiveness: a match is exhaustive iff the wildcard `_` +//! pattern is _not_ useful w.r.t. the patterns in the match. The values returned by `usefulness` +//! are used to tell the user which values are missing. +//! ```rust +//! match x { +//! Some(0) => ..., +//! None => ..., +//! // not exhaustive: `_` is useful because it matches `Some(1)` +//! } +//! ``` +//! +//! The entrypoint of this file is the [`compute_match_usefulness`] function, which computes +//! reachability for each match branch and exhaustiveness for the whole match. +//! +//! +//! # Constructors and fields +//! +//! Note: we will often abbreviate "constructor" as "ctor". +//! +//! The idea that powers everything that is done in this file is the following: a (matcheable) +//! value is made from a constructor applied to a number of subvalues. Examples of constructors are +//! `Some`, `None`, `(,)` (the 2-tuple constructor), `Foo {..}` (the constructor for a struct +//! `Foo`), and `2` (the constructor for the number `2`). This is natural when we think of +//! pattern-matching, and this is the basis for what follows. +//! +//! Some of the ctors listed above might feel weird: `None` and `2` don't take any arguments. +//! That's ok: those are ctors that take a list of 0 arguments; they are the simplest case of +//! ctors. We treat `2` as a ctor because `u64` and other number types behave exactly like a huge +//! `enum`, with one variant for each number. This allows us to see any matcheable value as made up +//! from a tree of ctors, each having a set number of children. For example: `Foo { bar: None, +//! baz: Ok(0) }` is made from 4 different ctors, namely `Foo{..}`, `None`, `Ok` and `0`. +//! +//! This idea can be extended to patterns: they are also made from constructors applied to fields. +//! A pattern for a given type is allowed to use all the ctors for values of that type (which we +//! call "value constructors"), but there are also pattern-only ctors. The most important one is +//! the wildcard (`_`), and the others are integer ranges (`0..=10`), variable-length slices (`[x, +//! ..]`), and or-patterns (`Ok(0) | Err(_)`). Examples of valid patterns are `42`, `Some(_)`, `Foo +//! { bar: Some(0) | None, baz: _ }`. Note that a binder in a pattern (e.g. `Some(x)`) matches the +//! same values as a wildcard (e.g. `Some(_)`), so we treat both as wildcards. +//! +//! From this deconstruction we can compute whether a given value matches a given pattern; we +//! simply look at ctors one at a time. Given a pattern `p` and a value `v`, we want to compute +//! `matches!(v, p)`. It's mostly straightforward: we compare the head ctors and when they match +//! we compare their fields recursively. A few representative examples: +//! +//! - `matches!(v, _) := true` +//! - `matches!((v0, v1), (p0, p1)) := matches!(v0, p0) && matches!(v1, p1)` +//! - `matches!(Foo { bar: v0, baz: v1 }, Foo { bar: p0, baz: p1 }) := matches!(v0, p0) && matches!(v1, p1)` +//! - `matches!(Ok(v0), Ok(p0)) := matches!(v0, p0)` +//! - `matches!(Ok(v0), Err(p0)) := false` (incompatible variants) +//! - `matches!(v, 1..=100) := matches!(v, 1) || ... || matches!(v, 100)` +//! - `matches!([v0], [p0, .., p1]) := false` (incompatible lengths) +//! - `matches!([v0, v1, v2], [p0, .., p1]) := matches!(v0, p0) && matches!(v2, p1)` +//! - `matches!(v, p0 | p1) := matches!(v, p0) || matches!(v, p1)` +//! +//! Constructors, fields and relevant operations are defined in the [`super::deconstruct_pat`] module. +//! +//! Note: this constructors/fields distinction may not straightforwardly apply to every Rust type. +//! For example a value of type `Rc<u64>` can't be deconstructed that way, and `&str` has an +//! infinitude of constructors. There are also subtleties with visibility of fields and +//! uninhabitedness and various other things. The constructors idea can be extended to handle most +//! of these subtleties though; caveats are documented where relevant throughout the code. +//! +//! Whether constructors cover each other is computed by [`Constructor::is_covered_by`]. +//! +//! +//! # Specialization +//! +//! Recall that we wish to compute `usefulness(p_1 .. p_n, q)`: given a list of patterns `p_1 .. +//! p_n` and a pattern `q`, all of the same type, we want to find a list of values (called +//! "witnesses") that are matched by `q` and by none of the `p_i`. We obviously don't just +//! enumerate all possible values. From the discussion above we see that we can proceed +//! ctor-by-ctor: for each value ctor of the given type, we ask "is there a value that starts with +//! this constructor and matches `q` and none of the `p_i`?". As we saw above, there's a lot we can +//! say from knowing only the first constructor of our candidate value. +//! +//! Let's take the following example: +//! ``` +//! match x { +//! Enum::Variant1(_) => {} // `p1` +//! Enum::Variant2(None, 0) => {} // `p2` +//! Enum::Variant2(Some(_), 0) => {} // `q` +//! } +//! ``` +//! +//! We can easily see that if our candidate value `v` starts with `Variant1` it will not match `q`. +//! If `v = Variant2(v0, v1)` however, whether or not it matches `p2` and `q` will depend on `v0` +//! and `v1`. In fact, such a `v` will be a witness of usefulness of `q` exactly when the tuple +//! `(v0, v1)` is a witness of usefulness of `q'` in the following reduced match: +//! +//! ``` +//! match x { +//! (None, 0) => {} // `p2'` +//! (Some(_), 0) => {} // `q'` +//! } +//! ``` +//! +//! This motivates a new step in computing usefulness, that we call _specialization_. +//! Specialization consist of filtering a list of patterns for those that match a constructor, and +//! then looking into the constructor's fields. This enables usefulness to be computed recursively. +//! +//! Instead of acting on a single pattern in each row, we will consider a list of patterns for each +//! row, and we call such a list a _pattern-stack_. The idea is that we will specialize the +//! leftmost pattern, which amounts to popping the constructor and pushing its fields, which feels +//! like a stack. We note a pattern-stack simply with `[p_1 ... p_n]`. +//! Here's a sequence of specializations of a list of pattern-stacks, to illustrate what's +//! happening: +//! ``` +//! [Enum::Variant1(_)] +//! [Enum::Variant2(None, 0)] +//! [Enum::Variant2(Some(_), 0)] +//! //==>> specialize with `Variant2` +//! [None, 0] +//! [Some(_), 0] +//! //==>> specialize with `Some` +//! [_, 0] +//! //==>> specialize with `true` (say the type was `bool`) +//! [0] +//! //==>> specialize with `0` +//! [] +//! ``` +//! +//! The function `specialize(c, p)` takes a value constructor `c` and a pattern `p`, and returns 0 +//! or more pattern-stacks. If `c` does not match the head constructor of `p`, it returns nothing; +//! otherwise if returns the fields of the constructor. This only returns more than one +//! pattern-stack if `p` has a pattern-only constructor. +//! +//! - Specializing for the wrong constructor returns nothing +//! +//! `specialize(None, Some(p0)) := []` +//! +//! - Specializing for the correct constructor returns a single row with the fields +//! +//! `specialize(Variant1, Variant1(p0, p1, p2)) := [[p0, p1, p2]]` +//! +//! `specialize(Foo{..}, Foo { bar: p0, baz: p1 }) := [[p0, p1]]` +//! +//! - For or-patterns, we specialize each branch and concatenate the results +//! +//! `specialize(c, p0 | p1) := specialize(c, p0) ++ specialize(c, p1)` +//! +//! - We treat the other pattern constructors as if they were a large or-pattern of all the +//! possibilities: +//! +//! `specialize(c, _) := specialize(c, Variant1(_) | Variant2(_, _) | ...)` +//! +//! `specialize(c, 1..=100) := specialize(c, 1 | ... | 100)` +//! +//! `specialize(c, [p0, .., p1]) := specialize(c, [p0, p1] | [p0, _, p1] | [p0, _, _, p1] | ...)` +//! +//! - If `c` is a pattern-only constructor, `specialize` is defined on a case-by-case basis. See +//! the discussion about constructor splitting in [`super::deconstruct_pat`]. +//! +//! +//! We then extend this function to work with pattern-stacks as input, by acting on the first +//! column and keeping the other columns untouched. +//! +//! Specialization for the whole matrix is done in [`Matrix::specialize_constructor`]. Note that +//! or-patterns in the first column are expanded before being stored in the matrix. Specialization +//! for a single patstack is done from a combination of [`Constructor::is_covered_by`] and +//! [`PatStack::pop_head_constructor`]. The internals of how it's done mostly live in the +//! [`Fields`] struct. +//! +//! +//! # Computing usefulness +//! +//! We now have all we need to compute usefulness. The inputs to usefulness are a list of +//! pattern-stacks `p_1 ... p_n` (one per row), and a new pattern_stack `q`. The paper and this +//! file calls the list of patstacks a _matrix_. They must all have the same number of columns and +//! the patterns in a given column must all have the same type. `usefulness` returns a (possibly +//! empty) list of witnesses of usefulness. These witnesses will also be pattern-stacks. +//! +//! - base case: `n_columns == 0`. +//! Since a pattern-stack functions like a tuple of patterns, an empty one functions like the +//! unit type. Thus `q` is useful iff there are no rows above it, i.e. if `n == 0`. +//! +//! - inductive case: `n_columns > 0`. +//! We need a way to list the constructors we want to try. We will be more clever in the next +//! section but for now assume we list all value constructors for the type of the first column. +//! +//! - for each such ctor `c`: +//! +//! - for each `q'` returned by `specialize(c, q)`: +//! +//! - we compute `usefulness(specialize(c, p_1) ... specialize(c, p_n), q')` +//! +//! - for each witness found, we revert specialization by pushing the constructor `c` on top. +//! +//! - We return the concatenation of all the witnesses found, if any. +//! +//! Example: +//! ``` +//! [Some(true)] // p_1 +//! [None] // p_2 +//! [Some(_)] // q +//! //==>> try `None`: `specialize(None, q)` returns nothing +//! //==>> try `Some`: `specialize(Some, q)` returns a single row +//! [true] // p_1' +//! [_] // q' +//! //==>> try `true`: `specialize(true, q')` returns a single row +//! [] // p_1'' +//! [] // q'' +//! //==>> base case; `n != 0` so `q''` is not useful. +//! //==>> go back up a step +//! [true] // p_1' +//! [_] // q' +//! //==>> try `false`: `specialize(false, q')` returns a single row +//! [] // q'' +//! //==>> base case; `n == 0` so `q''` is useful. We return the single witness `[]` +//! witnesses: +//! [] +//! //==>> undo the specialization with `false` +//! witnesses: +//! [false] +//! //==>> undo the specialization with `Some` +//! witnesses: +//! [Some(false)] +//! //==>> we have tried all the constructors. The output is the single witness `[Some(false)]`. +//! ``` +//! +//! This computation is done in [`is_useful`]. In practice we don't care about the list of +//! witnesses when computing reachability; we only need to know whether any exist. We do keep the +//! witnesses when computing exhaustiveness to report them to the user. +//! +//! +//! # Making usefulness tractable: constructor splitting +//! +//! We're missing one last detail: which constructors do we list? Naively listing all value +//! constructors cannot work for types like `u64` or `&str`, so we need to be more clever. The +//! first obvious insight is that we only want to list constructors that are covered by the head +//! constructor of `q`. If it's a value constructor, we only try that one. If it's a pattern-only +//! constructor, we use the final clever idea for this algorithm: _constructor splitting_, where we +//! group together constructors that behave the same. +//! +//! The details are not necessary to understand this file, so we explain them in +//! [`super::deconstruct_pat`]. Splitting is done by the [`Constructor::split`] function. + +use std::iter::once; + +use hir_def::{AdtId, DefWithBodyId, HasModule, ModuleId}; +use smallvec::{smallvec, SmallVec}; +use typed_arena::Arena; + +use crate::{db::HirDatabase, Ty, TyExt}; + +use super::deconstruct_pat::{Constructor, DeconstructedPat, Fields, SplitWildcard}; + +use self::{helper::Captures, ArmType::*, Usefulness::*}; + +pub(crate) struct MatchCheckCtx<'a, 'p> { + pub(crate) module: ModuleId, + pub(crate) body: DefWithBodyId, + pub(crate) db: &'a dyn HirDatabase, + /// Lowered patterns from arms plus generated by the check. + pub(crate) pattern_arena: &'p Arena<DeconstructedPat<'p>>, +} + +impl<'a, 'p> MatchCheckCtx<'a, 'p> { + pub(super) fn is_uninhabited(&self, _ty: &Ty) -> bool { + // FIXME(iDawer) implement exhaustive_patterns feature. More info in: + // Tracking issue for RFC 1872: exhaustive_patterns feature https://github.com/rust-lang/rust/issues/51085 + false + } + + /// Returns whether the given type is an enum from another crate declared `#[non_exhaustive]`. + pub(super) fn is_foreign_non_exhaustive_enum(&self, ty: &Ty) -> bool { + match ty.as_adt() { + Some((adt @ AdtId::EnumId(_), _)) => { + let has_non_exhaustive_attr = + self.db.attrs(adt.into()).by_key("non_exhaustive").exists(); + let is_local = adt.module(self.db.upcast()).krate() == self.module.krate(); + has_non_exhaustive_attr && !is_local + } + _ => false, + } + } + + // Rust feature described as "Allows exhaustive pattern matching on types that contain uninhabited types." + pub(super) fn feature_exhaustive_patterns(&self) -> bool { + // FIXME see MatchCheckCtx::is_uninhabited + false + } +} + +#[derive(Copy, Clone)] +pub(super) struct PatCtxt<'a, 'p> { + pub(super) cx: &'a MatchCheckCtx<'a, 'p>, + /// Type of the current column under investigation. + pub(super) ty: &'a Ty, + /// Whether the current pattern is the whole pattern as found in a match arm, or if it's a + /// subpattern. + pub(super) is_top_level: bool, + /// Whether the current pattern is from a `non_exhaustive` enum. + pub(super) is_non_exhaustive: bool, +} + +/// A row of a matrix. Rows of len 1 are very common, which is why `SmallVec[_; 2]` +/// works well. +#[derive(Clone)] +pub(super) struct PatStack<'p> { + pats: SmallVec<[&'p DeconstructedPat<'p>; 2]>, +} + +impl<'p> PatStack<'p> { + fn from_pattern(pat: &'p DeconstructedPat<'p>) -> Self { + Self::from_vec(smallvec![pat]) + } + + fn from_vec(vec: SmallVec<[&'p DeconstructedPat<'p>; 2]>) -> Self { + PatStack { pats: vec } + } + + fn is_empty(&self) -> bool { + self.pats.is_empty() + } + + fn len(&self) -> usize { + self.pats.len() + } + + fn head(&self) -> &'p DeconstructedPat<'p> { + self.pats[0] + } + + // Recursively expand the first pattern into its subpatterns. Only useful if the pattern is an + // or-pattern. Panics if `self` is empty. + fn expand_or_pat(&self) -> impl Iterator<Item = PatStack<'p>> + Captures<'_> { + self.head().iter_fields().map(move |pat| { + let mut new_patstack = PatStack::from_pattern(pat); + new_patstack.pats.extend_from_slice(&self.pats[1..]); + new_patstack + }) + } + + /// This computes `S(self.head().ctor(), self)`. See top of the file for explanations. + /// + /// Structure patterns with a partial wild pattern (Foo { a: 42, .. }) have their missing + /// fields filled with wild patterns. + /// + /// This is roughly the inverse of `Constructor::apply`. + fn pop_head_constructor(&self, cx: &MatchCheckCtx<'_, 'p>, ctor: &Constructor) -> PatStack<'p> { + // We pop the head pattern and push the new fields extracted from the arguments of + // `self.head()`. + let mut new_fields: SmallVec<[_; 2]> = self.head().specialize(cx, ctor); + new_fields.extend_from_slice(&self.pats[1..]); + PatStack::from_vec(new_fields) + } +} + +/// A 2D matrix. +#[derive(Clone)] +pub(super) struct Matrix<'p> { + patterns: Vec<PatStack<'p>>, +} + +impl<'p> Matrix<'p> { + fn empty() -> Self { + Matrix { patterns: vec![] } + } + + /// Number of columns of this matrix. `None` is the matrix is empty. + pub(super) fn _column_count(&self) -> Option<usize> { + self.patterns.get(0).map(|r| r.len()) + } + + /// Pushes a new row to the matrix. If the row starts with an or-pattern, this recursively + /// expands it. + fn push(&mut self, row: PatStack<'p>) { + if !row.is_empty() && row.head().is_or_pat() { + self.patterns.extend(row.expand_or_pat()); + } else { + self.patterns.push(row); + } + } + + /// Iterate over the first component of each row + fn heads(&self) -> impl Iterator<Item = &'p DeconstructedPat<'p>> + Clone + Captures<'_> { + self.patterns.iter().map(|r| r.head()) + } + + /// This computes `S(constructor, self)`. See top of the file for explanations. + fn specialize_constructor(&self, pcx: PatCtxt<'_, 'p>, ctor: &Constructor) -> Matrix<'p> { + let mut matrix = Matrix::empty(); + for row in &self.patterns { + if ctor.is_covered_by(pcx, row.head().ctor()) { + let new_row = row.pop_head_constructor(pcx.cx, ctor); + matrix.push(new_row); + } + } + matrix + } +} + +/// This carries the results of computing usefulness, as described at the top of the file. When +/// checking usefulness of a match branch, we use the `NoWitnesses` variant, which also keeps track +/// of potential unreachable sub-patterns (in the presence of or-patterns). When checking +/// exhaustiveness of a whole match, we use the `WithWitnesses` variant, which carries a list of +/// witnesses of non-exhaustiveness when there are any. +/// Which variant to use is dictated by `ArmType`. +enum Usefulness<'p> { + /// If we don't care about witnesses, simply remember if the pattern was useful. + NoWitnesses { useful: bool }, + /// Carries a list of witnesses of non-exhaustiveness. If empty, indicates that the whole + /// pattern is unreachable. + WithWitnesses(Vec<Witness<'p>>), +} + +impl<'p> Usefulness<'p> { + fn new_useful(preference: ArmType) -> Self { + match preference { + // A single (empty) witness of reachability. + FakeExtraWildcard => WithWitnesses(vec![Witness(vec![])]), + RealArm => NoWitnesses { useful: true }, + } + } + fn new_not_useful(preference: ArmType) -> Self { + match preference { + FakeExtraWildcard => WithWitnesses(vec![]), + RealArm => NoWitnesses { useful: false }, + } + } + + fn is_useful(&self) -> bool { + match self { + Usefulness::NoWitnesses { useful } => *useful, + Usefulness::WithWitnesses(witnesses) => !witnesses.is_empty(), + } + } + + /// Combine usefulnesses from two branches. This is an associative operation. + fn extend(&mut self, other: Self) { + match (&mut *self, other) { + (WithWitnesses(_), WithWitnesses(o)) if o.is_empty() => {} + (WithWitnesses(s), WithWitnesses(o)) if s.is_empty() => *self = WithWitnesses(o), + (WithWitnesses(s), WithWitnesses(o)) => s.extend(o), + (NoWitnesses { useful: s_useful }, NoWitnesses { useful: o_useful }) => { + *s_useful = *s_useful || o_useful + } + _ => unreachable!(), + } + } + + /// After calculating usefulness after a specialization, call this to reconstruct a usefulness + /// that makes sense for the matrix pre-specialization. This new usefulness can then be merged + /// with the results of specializing with the other constructors. + fn apply_constructor( + self, + pcx: PatCtxt<'_, 'p>, + matrix: &Matrix<'p>, + ctor: &Constructor, + ) -> Self { + match self { + NoWitnesses { .. } => self, + WithWitnesses(ref witnesses) if witnesses.is_empty() => self, + WithWitnesses(witnesses) => { + let new_witnesses = if let Constructor::Missing { .. } = ctor { + // We got the special `Missing` constructor, so each of the missing constructors + // gives a new pattern that is not caught by the match. We list those patterns. + let new_patterns = if pcx.is_non_exhaustive { + // Here we don't want the user to try to list all variants, we want them to add + // a wildcard, so we only suggest that. + vec![DeconstructedPat::wildcard(pcx.ty.clone())] + } else { + let mut split_wildcard = SplitWildcard::new(pcx); + split_wildcard.split(pcx, matrix.heads().map(DeconstructedPat::ctor)); + + // This lets us know if we skipped any variants because they are marked + // `doc(hidden)` or they are unstable feature gate (only stdlib types). + let mut hide_variant_show_wild = false; + // Construct for each missing constructor a "wild" version of this + // constructor, that matches everything that can be built with + // it. For example, if `ctor` is a `Constructor::Variant` for + // `Option::Some`, we get the pattern `Some(_)`. + let mut new: Vec<DeconstructedPat<'_>> = split_wildcard + .iter_missing(pcx) + .filter_map(|missing_ctor| { + // Check if this variant is marked `doc(hidden)` + if missing_ctor.is_doc_hidden_variant(pcx) + || missing_ctor.is_unstable_variant(pcx) + { + hide_variant_show_wild = true; + return None; + } + Some(DeconstructedPat::wild_from_ctor(pcx, missing_ctor.clone())) + }) + .collect(); + + if hide_variant_show_wild { + new.push(DeconstructedPat::wildcard(pcx.ty.clone())) + } + + new + }; + + witnesses + .into_iter() + .flat_map(|witness| { + new_patterns.iter().map(move |pat| { + Witness( + witness + .0 + .iter() + .chain(once(pat)) + .map(DeconstructedPat::clone_and_forget_reachability) + .collect(), + ) + }) + }) + .collect() + } else { + witnesses + .into_iter() + .map(|witness| witness.apply_constructor(pcx, ctor)) + .collect() + }; + WithWitnesses(new_witnesses) + } + } + } +} + +#[derive(Copy, Clone, Debug)] +enum ArmType { + FakeExtraWildcard, + RealArm, +} + +/// A witness of non-exhaustiveness for error reporting, represented +/// as a list of patterns (in reverse order of construction) with +/// wildcards inside to represent elements that can take any inhabitant +/// of the type as a value. +/// +/// A witness against a list of patterns should have the same types +/// and length as the pattern matched against. Because Rust `match` +/// is always against a single pattern, at the end the witness will +/// have length 1, but in the middle of the algorithm, it can contain +/// multiple patterns. +/// +/// For example, if we are constructing a witness for the match against +/// +/// ``` +/// struct Pair(Option<(u32, u32)>, bool); +/// +/// match (p: Pair) { +/// Pair(None, _) => {} +/// Pair(_, false) => {} +/// } +/// ``` +/// +/// We'll perform the following steps: +/// 1. Start with an empty witness +/// `Witness(vec![])` +/// 2. Push a witness `true` against the `false` +/// `Witness(vec![true])` +/// 3. Push a witness `Some(_)` against the `None` +/// `Witness(vec![true, Some(_)])` +/// 4. Apply the `Pair` constructor to the witnesses +/// `Witness(vec![Pair(Some(_), true)])` +/// +/// The final `Pair(Some(_), true)` is then the resulting witness. +pub(crate) struct Witness<'p>(Vec<DeconstructedPat<'p>>); + +impl<'p> Witness<'p> { + /// Asserts that the witness contains a single pattern, and returns it. + fn single_pattern(self) -> DeconstructedPat<'p> { + assert_eq!(self.0.len(), 1); + self.0.into_iter().next().unwrap() + } + + /// Constructs a partial witness for a pattern given a list of + /// patterns expanded by the specialization step. + /// + /// When a pattern P is discovered to be useful, this function is used bottom-up + /// to reconstruct a complete witness, e.g., a pattern P' that covers a subset + /// of values, V, where each value in that set is not covered by any previously + /// used patterns and is covered by the pattern P'. Examples: + /// + /// left_ty: tuple of 3 elements + /// pats: [10, 20, _] => (10, 20, _) + /// + /// left_ty: struct X { a: (bool, &'static str), b: usize} + /// pats: [(false, "foo"), 42] => X { a: (false, "foo"), b: 42 } + fn apply_constructor(mut self, pcx: PatCtxt<'_, 'p>, ctor: &Constructor) -> Self { + let pat = { + let len = self.0.len(); + let arity = ctor.arity(pcx); + let pats = self.0.drain((len - arity)..).rev(); + let fields = Fields::from_iter(pcx.cx, pats); + DeconstructedPat::new(ctor.clone(), fields, pcx.ty.clone()) + }; + + self.0.push(pat); + + self + } +} + +/// Algorithm from <http://moscova.inria.fr/~maranget/papers/warn/index.html>. +/// The algorithm from the paper has been modified to correctly handle empty +/// types. The changes are: +/// (0) We don't exit early if the pattern matrix has zero rows. We just +/// continue to recurse over columns. +/// (1) all_constructors will only return constructors that are statically +/// possible. E.g., it will only return `Ok` for `Result<T, !>`. +/// +/// This finds whether a (row) vector `v` of patterns is 'useful' in relation +/// to a set of such vectors `m` - this is defined as there being a set of +/// inputs that will match `v` but not any of the sets in `m`. +/// +/// All the patterns at each column of the `matrix ++ v` matrix must have the same type. +/// +/// This is used both for reachability checking (if a pattern isn't useful in +/// relation to preceding patterns, it is not reachable) and exhaustiveness +/// checking (if a wildcard pattern is useful in relation to a matrix, the +/// matrix isn't exhaustive). +/// +/// `is_under_guard` is used to inform if the pattern has a guard. If it +/// has one it must not be inserted into the matrix. This shouldn't be +/// relied on for soundness. +fn is_useful<'p>( + cx: &MatchCheckCtx<'_, 'p>, + matrix: &Matrix<'p>, + v: &PatStack<'p>, + witness_preference: ArmType, + is_under_guard: bool, + is_top_level: bool, +) -> Usefulness<'p> { + let Matrix { patterns: rows, .. } = matrix; + + // The base case. We are pattern-matching on () and the return value is + // based on whether our matrix has a row or not. + // NOTE: This could potentially be optimized by checking rows.is_empty() + // first and then, if v is non-empty, the return value is based on whether + // the type of the tuple we're checking is inhabited or not. + if v.is_empty() { + let ret = if rows.is_empty() { + Usefulness::new_useful(witness_preference) + } else { + Usefulness::new_not_useful(witness_preference) + }; + return ret; + } + + debug_assert!(rows.iter().all(|r| r.len() == v.len())); + + let ty = v.head().ty(); + let is_non_exhaustive = cx.is_foreign_non_exhaustive_enum(ty); + let pcx = PatCtxt { cx, ty, is_top_level, is_non_exhaustive }; + + // If the first pattern is an or-pattern, expand it. + let mut ret = Usefulness::new_not_useful(witness_preference); + if v.head().is_or_pat() { + // We try each or-pattern branch in turn. + let mut matrix = matrix.clone(); + for v in v.expand_or_pat() { + let usefulness = is_useful(cx, &matrix, &v, witness_preference, is_under_guard, false); + ret.extend(usefulness); + // If pattern has a guard don't add it to the matrix. + if !is_under_guard { + // We push the already-seen patterns into the matrix in order to detect redundant + // branches like `Some(_) | Some(0)`. + matrix.push(v); + } + } + } else { + let v_ctor = v.head().ctor(); + + // FIXME: implement `overlapping_range_endpoints` lint + + // We split the head constructor of `v`. + let split_ctors = v_ctor.split(pcx, matrix.heads().map(DeconstructedPat::ctor)); + // For each constructor, we compute whether there's a value that starts with it that would + // witness the usefulness of `v`. + let start_matrix = matrix; + for ctor in split_ctors { + // We cache the result of `Fields::wildcards` because it is used a lot. + let spec_matrix = start_matrix.specialize_constructor(pcx, &ctor); + let v = v.pop_head_constructor(cx, &ctor); + let usefulness = + is_useful(cx, &spec_matrix, &v, witness_preference, is_under_guard, false); + let usefulness = usefulness.apply_constructor(pcx, start_matrix, &ctor); + + // FIXME: implement `non_exhaustive_omitted_patterns` lint + + ret.extend(usefulness); + } + }; + + if ret.is_useful() { + v.head().set_reachable(); + } + + ret +} + +/// The arm of a match expression. +#[derive(Clone, Copy)] +pub(crate) struct MatchArm<'p> { + pub(crate) pat: &'p DeconstructedPat<'p>, + pub(crate) has_guard: bool, +} + +/// Indicates whether or not a given arm is reachable. +#[derive(Clone, Debug)] +pub(crate) enum Reachability { + /// The arm is reachable. This additionally carries a set of or-pattern branches that have been + /// found to be unreachable despite the overall arm being reachable. Used only in the presence + /// of or-patterns, otherwise it stays empty. + // FIXME: store ureachable subpattern IDs + Reachable, + /// The arm is unreachable. + Unreachable, +} + +/// The output of checking a match for exhaustiveness and arm reachability. +pub(crate) struct UsefulnessReport<'p> { + /// For each arm of the input, whether that arm is reachable after the arms above it. + pub(crate) _arm_usefulness: Vec<(MatchArm<'p>, Reachability)>, + /// If the match is exhaustive, this is empty. If not, this contains witnesses for the lack of + /// exhaustiveness. + pub(crate) non_exhaustiveness_witnesses: Vec<DeconstructedPat<'p>>, +} + +/// The entrypoint for the usefulness algorithm. Computes whether a match is exhaustive and which +/// of its arms are reachable. +/// +/// Note: the input patterns must have been lowered through +/// `check_match::MatchVisitor::lower_pattern`. +pub(crate) fn compute_match_usefulness<'p>( + cx: &MatchCheckCtx<'_, 'p>, + arms: &[MatchArm<'p>], + scrut_ty: &Ty, +) -> UsefulnessReport<'p> { + let mut matrix = Matrix::empty(); + let arm_usefulness = arms + .iter() + .copied() + .map(|arm| { + let v = PatStack::from_pattern(arm.pat); + is_useful(cx, &matrix, &v, RealArm, arm.has_guard, true); + if !arm.has_guard { + matrix.push(v); + } + let reachability = if arm.pat.is_reachable() { + Reachability::Reachable + } else { + Reachability::Unreachable + }; + (arm, reachability) + }) + .collect(); + + let wild_pattern = cx.pattern_arena.alloc(DeconstructedPat::wildcard(scrut_ty.clone())); + let v = PatStack::from_pattern(wild_pattern); + let usefulness = is_useful(cx, &matrix, &v, FakeExtraWildcard, false, true); + let non_exhaustiveness_witnesses = match usefulness { + WithWitnesses(pats) => pats.into_iter().map(Witness::single_pattern).collect(), + NoWitnesses { .. } => panic!("bug"), + }; + UsefulnessReport { _arm_usefulness: arm_usefulness, non_exhaustiveness_witnesses } +} + +pub(crate) mod helper { + // Copy-pasted from rust/compiler/rustc_data_structures/src/captures.rs + /// "Signaling" trait used in impl trait to tag lifetimes that you may + /// need to capture but don't really need for other reasons. + /// Basically a workaround; see [this comment] for details. + /// + /// [this comment]: https://github.com/rust-lang/rust/issues/34511#issuecomment-373423999 + // FIXME(eddyb) false positive, the lifetime parameter is "phantom" but needed. + #[allow(unused_lifetimes)] + pub(crate) trait Captures<'a> {} + + impl<'a, T: ?Sized> Captures<'a> for T {} +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs new file mode 100644 index 000000000..161b19a73 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs @@ -0,0 +1,104 @@ +//! Provides validations for unsafe code. Currently checks if unsafe functions are missing +//! unsafe blocks. + +use hir_def::{ + body::Body, + expr::{Expr, ExprId, UnaryOp}, + resolver::{resolver_for_expr, ResolveValueResult, ValueNs}, + DefWithBodyId, +}; + +use crate::{ + db::HirDatabase, utils::is_fn_unsafe_to_call, InferenceResult, Interner, TyExt, TyKind, +}; + +pub fn missing_unsafe(db: &dyn HirDatabase, def: DefWithBodyId) -> Vec<ExprId> { + let infer = db.infer(def); + let mut res = Vec::new(); + + let is_unsafe = match def { + DefWithBodyId::FunctionId(it) => db.function_data(it).has_unsafe_kw(), + DefWithBodyId::StaticId(_) | DefWithBodyId::ConstId(_) => false, + }; + if is_unsafe { + return res; + } + + let body = db.body(def); + unsafe_expressions(db, &infer, def, &body, body.body_expr, &mut |expr| { + if !expr.inside_unsafe_block { + res.push(expr.expr); + } + }); + + res +} + +pub struct UnsafeExpr { + pub expr: ExprId, + pub inside_unsafe_block: bool, +} + +// FIXME: Move this out, its not a diagnostic only thing anymore, and handle unsafe pattern accesses as well +pub fn unsafe_expressions( + db: &dyn HirDatabase, + infer: &InferenceResult, + def: DefWithBodyId, + body: &Body, + current: ExprId, + unsafe_expr_cb: &mut dyn FnMut(UnsafeExpr), +) { + walk_unsafe(db, infer, def, body, current, false, unsafe_expr_cb) +} + +fn walk_unsafe( + db: &dyn HirDatabase, + infer: &InferenceResult, + def: DefWithBodyId, + body: &Body, + current: ExprId, + inside_unsafe_block: bool, + unsafe_expr_cb: &mut dyn FnMut(UnsafeExpr), +) { + let expr = &body.exprs[current]; + match expr { + &Expr::Call { callee, .. } => { + if let Some(func) = infer[callee].as_fn_def(db) { + if is_fn_unsafe_to_call(db, func) { + unsafe_expr_cb(UnsafeExpr { expr: current, inside_unsafe_block }); + } + } + } + Expr::Path(path) => { + let resolver = resolver_for_expr(db.upcast(), def, current); + let value_or_partial = resolver.resolve_path_in_value_ns(db.upcast(), path.mod_path()); + if let Some(ResolveValueResult::ValueNs(ValueNs::StaticId(id))) = value_or_partial { + if db.static_data(id).mutable { + unsafe_expr_cb(UnsafeExpr { expr: current, inside_unsafe_block }); + } + } + } + Expr::MethodCall { .. } => { + if infer + .method_resolution(current) + .map(|(func, _)| is_fn_unsafe_to_call(db, func)) + .unwrap_or(false) + { + unsafe_expr_cb(UnsafeExpr { expr: current, inside_unsafe_block }); + } + } + Expr::UnaryOp { expr, op: UnaryOp::Deref } => { + if let TyKind::Raw(..) = &infer[*expr].kind(Interner) { + unsafe_expr_cb(UnsafeExpr { expr: current, inside_unsafe_block }); + } + } + Expr::Unsafe { body: child } => { + return walk_unsafe(db, infer, def, body, *child, true, unsafe_expr_cb); + } + _ => {} + } + + expr.walk_child_exprs(|child| { + walk_unsafe(db, infer, def, body, child, inside_unsafe_block, unsafe_expr_cb); + }); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs new file mode 100644 index 000000000..d2f9c2b8b --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs @@ -0,0 +1,1315 @@ +//! The `HirDisplay` trait, which serves two purposes: Turning various bits from +//! HIR back into source code, and just displaying them for debugging/testing +//! purposes. + +use std::fmt::{self, Debug}; + +use base_db::CrateId; +use chalk_ir::BoundVar; +use hir_def::{ + body, + db::DefDatabase, + find_path, + generics::{TypeOrConstParamData, TypeParamProvenance}, + intern::{Internable, Interned}, + item_scope::ItemInNs, + path::{Path, PathKind}, + type_ref::{ConstScalar, TraitBoundModifier, TypeBound, TypeRef}, + visibility::Visibility, + HasModule, ItemContainerId, Lookup, ModuleId, TraitId, +}; +use hir_expand::{hygiene::Hygiene, name::Name}; +use itertools::Itertools; +use syntax::SmolStr; + +use crate::{ + db::HirDatabase, + from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, lt_from_placeholder_idx, + mapping::from_chalk, + primitive, subst_prefix, to_assoc_type_id, + utils::{self, generics}, + AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Const, ConstValue, DomainGoal, + GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData, LifetimeOutlives, Mutability, + OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause, Scalar, Substitution, TraitRef, + TraitRefExt, Ty, TyExt, TyKind, WhereClause, +}; + +pub struct HirFormatter<'a> { + pub db: &'a dyn HirDatabase, + fmt: &'a mut dyn fmt::Write, + buf: String, + curr_size: usize, + pub(crate) max_size: Option<usize>, + omit_verbose_types: bool, + display_target: DisplayTarget, +} + +pub trait HirDisplay { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError>; + + /// Returns a `Display`able type that is human-readable. + fn into_displayable<'a>( + &'a self, + db: &'a dyn HirDatabase, + max_size: Option<usize>, + omit_verbose_types: bool, + display_target: DisplayTarget, + ) -> HirDisplayWrapper<'a, Self> + where + Self: Sized, + { + assert!( + !matches!(display_target, DisplayTarget::SourceCode { .. }), + "HirDisplayWrapper cannot fail with DisplaySourceCodeError, use HirDisplay::hir_fmt directly instead" + ); + HirDisplayWrapper { db, t: self, max_size, omit_verbose_types, display_target } + } + + /// Returns a `Display`able type that is human-readable. + /// Use this for showing types to the user (e.g. diagnostics) + fn display<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self> + where + Self: Sized, + { + HirDisplayWrapper { + db, + t: self, + max_size: None, + omit_verbose_types: false, + display_target: DisplayTarget::Diagnostics, + } + } + + /// Returns a `Display`able type that is human-readable and tries to be succinct. + /// Use this for showing types to the user where space is constrained (e.g. doc popups) + fn display_truncated<'a>( + &'a self, + db: &'a dyn HirDatabase, + max_size: Option<usize>, + ) -> HirDisplayWrapper<'a, Self> + where + Self: Sized, + { + HirDisplayWrapper { + db, + t: self, + max_size, + omit_verbose_types: true, + display_target: DisplayTarget::Diagnostics, + } + } + + /// Returns a String representation of `self` that can be inserted into the given module. + /// Use this when generating code (e.g. assists) + fn display_source_code<'a>( + &'a self, + db: &'a dyn HirDatabase, + module_id: ModuleId, + ) -> Result<String, DisplaySourceCodeError> { + let mut result = String::new(); + match self.hir_fmt(&mut HirFormatter { + db, + fmt: &mut result, + buf: String::with_capacity(20), + curr_size: 0, + max_size: None, + omit_verbose_types: false, + display_target: DisplayTarget::SourceCode { module_id }, + }) { + Ok(()) => {} + Err(HirDisplayError::FmtError) => panic!("Writing to String can't fail!"), + Err(HirDisplayError::DisplaySourceCodeError(e)) => return Err(e), + }; + Ok(result) + } + + /// Returns a String representation of `self` for test purposes + fn display_test<'a>(&'a self, db: &'a dyn HirDatabase) -> HirDisplayWrapper<'a, Self> + where + Self: Sized, + { + HirDisplayWrapper { + db, + t: self, + max_size: None, + omit_verbose_types: false, + display_target: DisplayTarget::Test, + } + } +} + +impl<'a> HirFormatter<'a> { + pub fn write_joined<T: HirDisplay>( + &mut self, + iter: impl IntoIterator<Item = T>, + sep: &str, + ) -> Result<(), HirDisplayError> { + let mut first = true; + for e in iter { + if !first { + write!(self, "{}", sep)?; + } + first = false; + + // Abbreviate multiple omitted types with a single ellipsis. + if self.should_truncate() { + return write!(self, "{}", TYPE_HINT_TRUNCATION); + } + + e.hir_fmt(self)?; + } + Ok(()) + } + + /// This allows using the `write!` macro directly with a `HirFormatter`. + pub fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<(), HirDisplayError> { + // We write to a buffer first to track output size + self.buf.clear(); + fmt::write(&mut self.buf, args)?; + self.curr_size += self.buf.len(); + + // Then we write to the internal formatter from the buffer + self.fmt.write_str(&self.buf).map_err(HirDisplayError::from) + } + + pub fn write_str(&mut self, s: &str) -> Result<(), HirDisplayError> { + self.fmt.write_str(s)?; + Ok(()) + } + + pub fn write_char(&mut self, c: char) -> Result<(), HirDisplayError> { + self.fmt.write_char(c)?; + Ok(()) + } + + pub fn should_truncate(&self) -> bool { + match self.max_size { + Some(max_size) => self.curr_size >= max_size, + None => false, + } + } + + pub fn omit_verbose_types(&self) -> bool { + self.omit_verbose_types + } +} + +#[derive(Clone, Copy)] +pub enum DisplayTarget { + /// Display types for inlays, doc popups, autocompletion, etc... + /// Showing `{unknown}` or not qualifying paths is fine here. + /// There's no reason for this to fail. + Diagnostics, + /// Display types for inserting them in source files. + /// The generated code should compile, so paths need to be qualified. + SourceCode { module_id: ModuleId }, + /// Only for test purpose to keep real types + Test, +} + +impl DisplayTarget { + fn is_source_code(&self) -> bool { + matches!(self, Self::SourceCode { .. }) + } + fn is_test(&self) -> bool { + matches!(self, Self::Test) + } +} + +#[derive(Debug)] +pub enum DisplaySourceCodeError { + PathNotFound, + UnknownType, + Closure, +} + +pub enum HirDisplayError { + /// Errors that can occur when generating source code + DisplaySourceCodeError(DisplaySourceCodeError), + /// `FmtError` is required to be compatible with std::fmt::Display + FmtError, +} +impl From<fmt::Error> for HirDisplayError { + fn from(_: fmt::Error) -> Self { + Self::FmtError + } +} + +pub struct HirDisplayWrapper<'a, T> { + db: &'a dyn HirDatabase, + t: &'a T, + max_size: Option<usize>, + omit_verbose_types: bool, + display_target: DisplayTarget, +} + +impl<'a, T> fmt::Display for HirDisplayWrapper<'a, T> +where + T: HirDisplay, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self.t.hir_fmt(&mut HirFormatter { + db: self.db, + fmt: f, + buf: String::with_capacity(20), + curr_size: 0, + max_size: self.max_size, + omit_verbose_types: self.omit_verbose_types, + display_target: self.display_target, + }) { + Ok(()) => Ok(()), + Err(HirDisplayError::FmtError) => Err(fmt::Error), + Err(HirDisplayError::DisplaySourceCodeError(_)) => { + // This should never happen + panic!("HirDisplay::hir_fmt failed with DisplaySourceCodeError when calling Display::fmt!") + } + } + } +} + +const TYPE_HINT_TRUNCATION: &str = "…"; + +impl<T: HirDisplay> HirDisplay for &'_ T { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + HirDisplay::hir_fmt(*self, f) + } +} + +impl<T: HirDisplay + Internable> HirDisplay for Interned<T> { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + HirDisplay::hir_fmt(self.as_ref(), f) + } +} + +impl HirDisplay for ProjectionTy { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + if f.should_truncate() { + return write!(f, "{}", TYPE_HINT_TRUNCATION); + } + + let trait_ = f.db.trait_data(self.trait_(f.db)); + write!(f, "<")?; + self.self_type_parameter(Interner).hir_fmt(f)?; + write!(f, " as {}", trait_.name)?; + if self.substitution.len(Interner) > 1 { + write!(f, "<")?; + f.write_joined(&self.substitution.as_slice(Interner)[1..], ", ")?; + write!(f, ">")?; + } + write!(f, ">::{}", f.db.type_alias_data(from_assoc_type_id(self.associated_ty_id)).name)?; + Ok(()) + } +} + +impl HirDisplay for OpaqueTy { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + if f.should_truncate() { + return write!(f, "{}", TYPE_HINT_TRUNCATION); + } + + self.substitution.at(Interner, 0).hir_fmt(f) + } +} + +impl HirDisplay for GenericArg { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match self.interned() { + crate::GenericArgData::Ty(ty) => ty.hir_fmt(f), + crate::GenericArgData::Lifetime(lt) => lt.hir_fmt(f), + crate::GenericArgData::Const(c) => c.hir_fmt(f), + } + } +} + +impl HirDisplay for Const { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + let data = self.interned(); + match data.value { + ConstValue::BoundVar(idx) => idx.hir_fmt(f), + ConstValue::InferenceVar(..) => write!(f, "#c#"), + ConstValue::Placeholder(idx) => { + let id = from_placeholder_idx(f.db, idx); + let generics = generics(f.db.upcast(), id.parent); + let param_data = &generics.params.type_or_consts[id.local_id]; + write!(f, "{}", param_data.name().unwrap()) + } + ConstValue::Concrete(c) => write!(f, "{}", c.interned), + } + } +} + +impl HirDisplay for BoundVar { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + write!(f, "?{}.{}", self.debruijn.depth(), self.index) + } +} + +impl HirDisplay for Ty { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + if f.should_truncate() { + return write!(f, "{}", TYPE_HINT_TRUNCATION); + } + + match self.kind(Interner) { + TyKind::Never => write!(f, "!")?, + TyKind::Str => write!(f, "str")?, + TyKind::Scalar(Scalar::Bool) => write!(f, "bool")?, + TyKind::Scalar(Scalar::Char) => write!(f, "char")?, + &TyKind::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?, + &TyKind::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?, + &TyKind::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?, + TyKind::Slice(t) => { + write!(f, "[")?; + t.hir_fmt(f)?; + write!(f, "]")?; + } + TyKind::Array(t, c) => { + write!(f, "[")?; + t.hir_fmt(f)?; + write!(f, "; ")?; + c.hir_fmt(f)?; + write!(f, "]")?; + } + TyKind::Raw(m, t) | TyKind::Ref(m, _, t) => { + if matches!(self.kind(Interner), TyKind::Raw(..)) { + write!( + f, + "*{}", + match m { + Mutability::Not => "const ", + Mutability::Mut => "mut ", + } + )?; + } else { + write!( + f, + "&{}", + match m { + Mutability::Not => "", + Mutability::Mut => "mut ", + } + )?; + } + + // FIXME: all this just to decide whether to use parentheses... + let contains_impl_fn = |bounds: &[QuantifiedWhereClause]| { + bounds.iter().any(|bound| { + if let WhereClause::Implemented(trait_ref) = bound.skip_binders() { + let trait_ = trait_ref.hir_trait_id(); + fn_traits(f.db.upcast(), trait_).any(|it| it == trait_) + } else { + false + } + }) + }; + let (preds_to_print, has_impl_fn_pred) = match t.kind(Interner) { + TyKind::Dyn(dyn_ty) if dyn_ty.bounds.skip_binders().interned().len() > 1 => { + let bounds = dyn_ty.bounds.skip_binders().interned(); + (bounds.len(), contains_impl_fn(bounds)) + } + TyKind::Alias(AliasTy::Opaque(OpaqueTy { + opaque_ty_id, + substitution: parameters, + })) + | TyKind::OpaqueType(opaque_ty_id, parameters) => { + let impl_trait_id = + f.db.lookup_intern_impl_trait_id((*opaque_ty_id).into()); + if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id { + let datas = + f.db.return_type_impl_traits(func) + .expect("impl trait id without data"); + let data = (*datas) + .as_ref() + .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); + let bounds = data.substitute(Interner, parameters); + let mut len = bounds.skip_binders().len(); + + // Don't count Sized but count when it absent + // (i.e. when explicit ?Sized bound is set). + let default_sized = SizedByDefault::Sized { + anchor: func.lookup(f.db.upcast()).module(f.db.upcast()).krate(), + }; + let sized_bounds = bounds + .skip_binders() + .iter() + .filter(|b| { + matches!( + b.skip_binders(), + WhereClause::Implemented(trait_ref) + if default_sized.is_sized_trait( + trait_ref.hir_trait_id(), + f.db.upcast(), + ), + ) + }) + .count(); + match sized_bounds { + 0 => len += 1, + _ => { + len = len.saturating_sub(sized_bounds); + } + } + + (len, contains_impl_fn(bounds.skip_binders())) + } else { + (0, false) + } + } + _ => (0, false), + }; + + if has_impl_fn_pred && preds_to_print <= 2 { + return t.hir_fmt(f); + } + + if preds_to_print > 1 { + write!(f, "(")?; + t.hir_fmt(f)?; + write!(f, ")")?; + } else { + t.hir_fmt(f)?; + } + } + TyKind::Tuple(_, substs) => { + if substs.len(Interner) == 1 { + write!(f, "(")?; + substs.at(Interner, 0).hir_fmt(f)?; + write!(f, ",)")?; + } else { + write!(f, "(")?; + f.write_joined(&*substs.as_slice(Interner), ", ")?; + write!(f, ")")?; + } + } + TyKind::Function(fn_ptr) => { + let sig = CallableSig::from_fn_ptr(fn_ptr); + sig.hir_fmt(f)?; + } + TyKind::FnDef(def, parameters) => { + let def = from_chalk(f.db, *def); + let sig = f.db.callable_item_signature(def).substitute(Interner, parameters); + match def { + CallableDefId::FunctionId(ff) => { + write!(f, "fn {}", f.db.function_data(ff).name)? + } + CallableDefId::StructId(s) => write!(f, "{}", f.db.struct_data(s).name)?, + CallableDefId::EnumVariantId(e) => { + write!(f, "{}", f.db.enum_data(e.parent).variants[e.local_id].name)? + } + }; + if parameters.len(Interner) > 0 { + let generics = generics(f.db.upcast(), def.into()); + let (parent_params, self_param, type_params, const_params, _impl_trait_params) = + generics.provenance_split(); + let total_len = parent_params + self_param + type_params + const_params; + // We print all params except implicit impl Trait params. Still a bit weird; should we leave out parent and self? + if total_len > 0 { + write!(f, "<")?; + f.write_joined(¶meters.as_slice(Interner)[..total_len], ", ")?; + write!(f, ">")?; + } + } + write!(f, "(")?; + f.write_joined(sig.params(), ", ")?; + write!(f, ")")?; + let ret = sig.ret(); + if !ret.is_unit() { + write!(f, " -> ")?; + ret.hir_fmt(f)?; + } + } + TyKind::Adt(AdtId(def_id), parameters) => { + match f.display_target { + DisplayTarget::Diagnostics | DisplayTarget::Test => { + let name = match *def_id { + hir_def::AdtId::StructId(it) => f.db.struct_data(it).name.clone(), + hir_def::AdtId::UnionId(it) => f.db.union_data(it).name.clone(), + hir_def::AdtId::EnumId(it) => f.db.enum_data(it).name.clone(), + }; + write!(f, "{}", name)?; + } + DisplayTarget::SourceCode { module_id } => { + if let Some(path) = find_path::find_path( + f.db.upcast(), + ItemInNs::Types((*def_id).into()), + module_id, + ) { + write!(f, "{}", path)?; + } else { + return Err(HirDisplayError::DisplaySourceCodeError( + DisplaySourceCodeError::PathNotFound, + )); + } + } + } + + if parameters.len(Interner) > 0 { + let parameters_to_write = if f.display_target.is_source_code() + || f.omit_verbose_types() + { + match self + .as_generic_def(f.db) + .map(|generic_def_id| f.db.generic_defaults(generic_def_id)) + .filter(|defaults| !defaults.is_empty()) + { + None => parameters.as_slice(Interner), + Some(default_parameters) => { + fn should_show( + parameter: &GenericArg, + default_parameters: &[Binders<GenericArg>], + i: usize, + parameters: &Substitution, + ) -> bool { + if parameter.ty(Interner).map(|x| x.kind(Interner)) + == Some(&TyKind::Error) + { + return true; + } + if let Some(ConstValue::Concrete(c)) = + parameter.constant(Interner).map(|x| x.data(Interner).value) + { + if c.interned == ConstScalar::Unknown { + return true; + } + } + let default_parameter = match default_parameters.get(i) { + Some(x) => x, + None => return true, + }; + let actual_default = default_parameter + .clone() + .substitute(Interner, &subst_prefix(parameters, i)); + parameter != &actual_default + } + let mut default_from = 0; + for (i, parameter) in parameters.iter(Interner).enumerate() { + if should_show(parameter, &default_parameters, i, parameters) { + default_from = i + 1; + } + } + ¶meters.as_slice(Interner)[0..default_from] + } + } + } else { + parameters.as_slice(Interner) + }; + if !parameters_to_write.is_empty() { + write!(f, "<")?; + + if f.display_target.is_source_code() { + let mut first = true; + for generic_arg in parameters_to_write { + if !first { + write!(f, ", ")?; + } + first = false; + + if generic_arg.ty(Interner).map(|ty| ty.kind(Interner)) + == Some(&TyKind::Error) + { + write!(f, "_")?; + } else { + generic_arg.hir_fmt(f)?; + } + } + } else { + f.write_joined(parameters_to_write, ", ")?; + } + + write!(f, ">")?; + } + } + } + TyKind::AssociatedType(assoc_type_id, parameters) => { + let type_alias = from_assoc_type_id(*assoc_type_id); + let trait_ = match type_alias.lookup(f.db.upcast()).container { + ItemContainerId::TraitId(it) => it, + _ => panic!("not an associated type"), + }; + let trait_ = f.db.trait_data(trait_); + let type_alias_data = f.db.type_alias_data(type_alias); + + // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types) + if f.display_target.is_test() { + write!(f, "{}::{}", trait_.name, type_alias_data.name)?; + if parameters.len(Interner) > 0 { + write!(f, "<")?; + f.write_joined(&*parameters.as_slice(Interner), ", ")?; + write!(f, ">")?; + } + } else { + let projection_ty = ProjectionTy { + associated_ty_id: to_assoc_type_id(type_alias), + substitution: parameters.clone(), + }; + + projection_ty.hir_fmt(f)?; + } + } + TyKind::Foreign(type_alias) => { + let type_alias = f.db.type_alias_data(from_foreign_def_id(*type_alias)); + write!(f, "{}", type_alias.name)?; + } + TyKind::OpaqueType(opaque_ty_id, parameters) => { + let impl_trait_id = f.db.lookup_intern_impl_trait_id((*opaque_ty_id).into()); + match impl_trait_id { + ImplTraitId::ReturnTypeImplTrait(func, idx) => { + let datas = + f.db.return_type_impl_traits(func).expect("impl trait id without data"); + let data = (*datas) + .as_ref() + .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); + let bounds = data.substitute(Interner, ¶meters); + let krate = func.lookup(f.db.upcast()).module(f.db.upcast()).krate(); + write_bounds_like_dyn_trait_with_prefix( + "impl", + bounds.skip_binders(), + SizedByDefault::Sized { anchor: krate }, + f, + )?; + // FIXME: it would maybe be good to distinguish this from the alias type (when debug printing), and to show the substitution + } + ImplTraitId::AsyncBlockTypeImplTrait(..) => { + write!(f, "impl Future<Output = ")?; + parameters.at(Interner, 0).hir_fmt(f)?; + write!(f, ">")?; + } + } + } + TyKind::Closure(.., substs) => { + if f.display_target.is_source_code() { + return Err(HirDisplayError::DisplaySourceCodeError( + DisplaySourceCodeError::Closure, + )); + } + let sig = substs.at(Interner, 0).assert_ty_ref(Interner).callable_sig(f.db); + if let Some(sig) = sig { + if sig.params().is_empty() { + write!(f, "||")?; + } else if f.should_truncate() { + write!(f, "|{}|", TYPE_HINT_TRUNCATION)?; + } else { + write!(f, "|")?; + f.write_joined(sig.params(), ", ")?; + write!(f, "|")?; + }; + + write!(f, " -> ")?; + sig.ret().hir_fmt(f)?; + } else { + write!(f, "{{closure}}")?; + } + } + TyKind::Placeholder(idx) => { + let id = from_placeholder_idx(f.db, *idx); + let generics = generics(f.db.upcast(), id.parent); + let param_data = &generics.params.type_or_consts[id.local_id]; + match param_data { + TypeOrConstParamData::TypeParamData(p) => match p.provenance { + TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => { + write!(f, "{}", p.name.clone().unwrap_or_else(Name::missing))? + } + TypeParamProvenance::ArgumentImplTrait => { + let substs = generics.placeholder_subst(f.db); + let bounds = + f.db.generic_predicates(id.parent) + .iter() + .map(|pred| pred.clone().substitute(Interner, &substs)) + .filter(|wc| match &wc.skip_binders() { + WhereClause::Implemented(tr) => { + &tr.self_type_parameter(Interner) == self + } + WhereClause::AliasEq(AliasEq { + alias: AliasTy::Projection(proj), + ty: _, + }) => &proj.self_type_parameter(Interner) == self, + _ => false, + }) + .collect::<Vec<_>>(); + let krate = id.parent.module(f.db.upcast()).krate(); + write_bounds_like_dyn_trait_with_prefix( + "impl", + &bounds, + SizedByDefault::Sized { anchor: krate }, + f, + )?; + } + }, + TypeOrConstParamData::ConstParamData(p) => { + write!(f, "{}", p.name)?; + } + } + } + TyKind::BoundVar(idx) => idx.hir_fmt(f)?, + TyKind::Dyn(dyn_ty) => { + write_bounds_like_dyn_trait_with_prefix( + "dyn", + dyn_ty.bounds.skip_binders().interned(), + SizedByDefault::NotSized, + f, + )?; + } + TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?, + TyKind::Alias(AliasTy::Opaque(opaque_ty)) => { + let impl_trait_id = f.db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into()); + match impl_trait_id { + ImplTraitId::ReturnTypeImplTrait(func, idx) => { + let datas = + f.db.return_type_impl_traits(func).expect("impl trait id without data"); + let data = (*datas) + .as_ref() + .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone()); + let bounds = data.substitute(Interner, &opaque_ty.substitution); + let krate = func.lookup(f.db.upcast()).module(f.db.upcast()).krate(); + write_bounds_like_dyn_trait_with_prefix( + "impl", + bounds.skip_binders(), + SizedByDefault::Sized { anchor: krate }, + f, + )?; + } + ImplTraitId::AsyncBlockTypeImplTrait(..) => { + write!(f, "{{async block}}")?; + } + }; + } + TyKind::Error => { + if f.display_target.is_source_code() { + return Err(HirDisplayError::DisplaySourceCodeError( + DisplaySourceCodeError::UnknownType, + )); + } + write!(f, "{{unknown}}")?; + } + TyKind::InferenceVar(..) => write!(f, "_")?, + TyKind::Generator(..) => write!(f, "{{generator}}")?, + TyKind::GeneratorWitness(..) => write!(f, "{{generator witness}}")?, + } + Ok(()) + } +} + +impl HirDisplay for CallableSig { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + write!(f, "fn(")?; + f.write_joined(self.params(), ", ")?; + if self.is_varargs { + if self.params().is_empty() { + write!(f, "...")?; + } else { + write!(f, ", ...")?; + } + } + write!(f, ")")?; + let ret = self.ret(); + if !ret.is_unit() { + write!(f, " -> ")?; + ret.hir_fmt(f)?; + } + Ok(()) + } +} + +fn fn_traits(db: &dyn DefDatabase, trait_: TraitId) -> impl Iterator<Item = TraitId> { + let krate = trait_.lookup(db).container.krate(); + utils::fn_traits(db, krate) +} + +#[derive(Clone, Copy, PartialEq, Eq)] +pub enum SizedByDefault { + NotSized, + Sized { anchor: CrateId }, +} + +impl SizedByDefault { + fn is_sized_trait(self, trait_: TraitId, db: &dyn DefDatabase) -> bool { + match self { + Self::NotSized => false, + Self::Sized { anchor } => { + let sized_trait = db + .lang_item(anchor, SmolStr::new_inline("sized")) + .and_then(|lang_item| lang_item.as_trait()); + Some(trait_) == sized_trait + } + } + } +} + +pub fn write_bounds_like_dyn_trait_with_prefix( + prefix: &str, + predicates: &[QuantifiedWhereClause], + default_sized: SizedByDefault, + f: &mut HirFormatter<'_>, +) -> Result<(), HirDisplayError> { + write!(f, "{}", prefix)?; + if !predicates.is_empty() + || predicates.is_empty() && matches!(default_sized, SizedByDefault::Sized { .. }) + { + write!(f, " ")?; + write_bounds_like_dyn_trait(predicates, default_sized, f) + } else { + Ok(()) + } +} + +fn write_bounds_like_dyn_trait( + predicates: &[QuantifiedWhereClause], + default_sized: SizedByDefault, + f: &mut HirFormatter<'_>, +) -> Result<(), HirDisplayError> { + // Note: This code is written to produce nice results (i.e. + // corresponding to surface Rust) for types that can occur in + // actual Rust. It will have weird results if the predicates + // aren't as expected (i.e. self types = $0, projection + // predicates for a certain trait come after the Implemented + // predicate for that trait). + let mut first = true; + let mut angle_open = false; + let mut is_fn_trait = false; + let mut is_sized = false; + for p in predicates.iter() { + match p.skip_binders() { + WhereClause::Implemented(trait_ref) => { + let trait_ = trait_ref.hir_trait_id(); + if default_sized.is_sized_trait(trait_, f.db.upcast()) { + is_sized = true; + if matches!(default_sized, SizedByDefault::Sized { .. }) { + // Don't print +Sized, but rather +?Sized if absent. + continue; + } + } + if !is_fn_trait { + is_fn_trait = fn_traits(f.db.upcast(), trait_).any(|it| it == trait_); + } + if !is_fn_trait && angle_open { + write!(f, ">")?; + angle_open = false; + } + if !first { + write!(f, " + ")?; + } + // We assume that the self type is ^0.0 (i.e. the + // existential) here, which is the only thing that's + // possible in actual Rust, and hence don't print it + write!(f, "{}", f.db.trait_data(trait_).name)?; + if let [_, params @ ..] = &*trait_ref.substitution.as_slice(Interner) { + if is_fn_trait { + if let Some(args) = + params.first().and_then(|it| it.assert_ty_ref(Interner).as_tuple()) + { + write!(f, "(")?; + f.write_joined(args.as_slice(Interner), ", ")?; + write!(f, ")")?; + } + } else if !params.is_empty() { + write!(f, "<")?; + f.write_joined(params, ", ")?; + // there might be assoc type bindings, so we leave the angle brackets open + angle_open = true; + } + } + } + WhereClause::AliasEq(alias_eq) if is_fn_trait => { + is_fn_trait = false; + if !alias_eq.ty.is_unit() { + write!(f, " -> ")?; + alias_eq.ty.hir_fmt(f)?; + } + } + WhereClause::AliasEq(AliasEq { ty, alias }) => { + // in types in actual Rust, these will always come + // after the corresponding Implemented predicate + if angle_open { + write!(f, ", ")?; + } else { + write!(f, "<")?; + angle_open = true; + } + if let AliasTy::Projection(proj) = alias { + let type_alias = + f.db.type_alias_data(from_assoc_type_id(proj.associated_ty_id)); + write!(f, "{} = ", type_alias.name)?; + } + ty.hir_fmt(f)?; + } + + // FIXME implement these + WhereClause::LifetimeOutlives(_) => {} + WhereClause::TypeOutlives(_) => {} + } + first = false; + } + if angle_open { + write!(f, ">")?; + } + if matches!(default_sized, SizedByDefault::Sized { .. }) { + if !is_sized { + write!(f, "{}?Sized", if first { "" } else { " + " })?; + } else if first { + write!(f, "Sized")?; + } + } + Ok(()) +} + +fn fmt_trait_ref( + tr: &TraitRef, + f: &mut HirFormatter<'_>, + use_as: bool, +) -> Result<(), HirDisplayError> { + if f.should_truncate() { + return write!(f, "{}", TYPE_HINT_TRUNCATION); + } + + tr.self_type_parameter(Interner).hir_fmt(f)?; + if use_as { + write!(f, " as ")?; + } else { + write!(f, ": ")?; + } + write!(f, "{}", f.db.trait_data(tr.hir_trait_id()).name)?; + if tr.substitution.len(Interner) > 1 { + write!(f, "<")?; + f.write_joined(&tr.substitution.as_slice(Interner)[1..], ", ")?; + write!(f, ">")?; + } + Ok(()) +} + +impl HirDisplay for TraitRef { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + fmt_trait_ref(self, f, false) + } +} + +impl HirDisplay for WhereClause { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + if f.should_truncate() { + return write!(f, "{}", TYPE_HINT_TRUNCATION); + } + + match self { + WhereClause::Implemented(trait_ref) => trait_ref.hir_fmt(f)?, + WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => { + write!(f, "<")?; + fmt_trait_ref(&projection_ty.trait_ref(f.db), f, true)?; + write!( + f, + ">::{} = ", + f.db.type_alias_data(from_assoc_type_id(projection_ty.associated_ty_id)).name, + )?; + ty.hir_fmt(f)?; + } + WhereClause::AliasEq(_) => write!(f, "{{error}}")?, + + // FIXME implement these + WhereClause::TypeOutlives(..) => {} + WhereClause::LifetimeOutlives(..) => {} + } + Ok(()) + } +} + +impl HirDisplay for LifetimeOutlives { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + self.a.hir_fmt(f)?; + write!(f, ": ")?; + self.b.hir_fmt(f) + } +} + +impl HirDisplay for Lifetime { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + self.interned().hir_fmt(f) + } +} + +impl HirDisplay for LifetimeData { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match self { + LifetimeData::BoundVar(idx) => idx.hir_fmt(f), + LifetimeData::InferenceVar(_) => write!(f, "_"), + LifetimeData::Placeholder(idx) => { + let id = lt_from_placeholder_idx(f.db, *idx); + let generics = generics(f.db.upcast(), id.parent); + let param_data = &generics.params.lifetimes[id.local_id]; + write!(f, "{}", param_data.name) + } + LifetimeData::Static => write!(f, "'static"), + LifetimeData::Empty(_) => Ok(()), + LifetimeData::Erased => Ok(()), + LifetimeData::Phantom(_, _) => Ok(()), + } + } +} + +impl HirDisplay for DomainGoal { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match self { + DomainGoal::Holds(wc) => { + write!(f, "Holds(")?; + wc.hir_fmt(f)?; + write!(f, ")")?; + } + _ => write!(f, "?")?, + } + Ok(()) + } +} + +pub fn write_visibility( + module_id: ModuleId, + vis: Visibility, + f: &mut HirFormatter<'_>, +) -> Result<(), HirDisplayError> { + match vis { + Visibility::Public => write!(f, "pub "), + Visibility::Module(vis_id) => { + let def_map = module_id.def_map(f.db.upcast()); + let root_module_id = def_map.module_id(def_map.root()); + if vis_id == module_id { + // pub(self) or omitted + Ok(()) + } else if root_module_id == vis_id { + write!(f, "pub(crate) ") + } else if module_id.containing_module(f.db.upcast()) == Some(vis_id) { + write!(f, "pub(super) ") + } else { + write!(f, "pub(in ...) ") + } + } + } +} + +impl HirDisplay for TypeRef { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match self { + TypeRef::Never => write!(f, "!")?, + TypeRef::Placeholder => write!(f, "_")?, + TypeRef::Tuple(elems) => { + write!(f, "(")?; + f.write_joined(elems, ", ")?; + if elems.len() == 1 { + write!(f, ",")?; + } + write!(f, ")")?; + } + TypeRef::Path(path) => path.hir_fmt(f)?, + TypeRef::RawPtr(inner, mutability) => { + let mutability = match mutability { + hir_def::type_ref::Mutability::Shared => "*const ", + hir_def::type_ref::Mutability::Mut => "*mut ", + }; + write!(f, "{}", mutability)?; + inner.hir_fmt(f)?; + } + TypeRef::Reference(inner, lifetime, mutability) => { + let mutability = match mutability { + hir_def::type_ref::Mutability::Shared => "", + hir_def::type_ref::Mutability::Mut => "mut ", + }; + write!(f, "&")?; + if let Some(lifetime) = lifetime { + write!(f, "{} ", lifetime.name)?; + } + write!(f, "{}", mutability)?; + inner.hir_fmt(f)?; + } + TypeRef::Array(inner, len) => { + write!(f, "[")?; + inner.hir_fmt(f)?; + write!(f, "; {}]", len)?; + } + TypeRef::Slice(inner) => { + write!(f, "[")?; + inner.hir_fmt(f)?; + write!(f, "]")?; + } + TypeRef::Fn(parameters, is_varargs) => { + // FIXME: Function pointer qualifiers. + write!(f, "fn(")?; + if let Some(((_, return_type), function_parameters)) = parameters.split_last() { + for index in 0..function_parameters.len() { + let (param_name, param_type) = &function_parameters[index]; + if let Some(name) = param_name { + write!(f, "{}: ", name)?; + } + + param_type.hir_fmt(f)?; + + if index != function_parameters.len() - 1 { + write!(f, ", ")?; + } + } + if *is_varargs { + write!(f, "{}...", if parameters.len() == 1 { "" } else { ", " })?; + } + write!(f, ")")?; + match &return_type { + TypeRef::Tuple(tup) if tup.is_empty() => {} + _ => { + write!(f, " -> ")?; + return_type.hir_fmt(f)?; + } + } + } + } + TypeRef::ImplTrait(bounds) => { + write!(f, "impl ")?; + f.write_joined(bounds, " + ")?; + } + TypeRef::DynTrait(bounds) => { + write!(f, "dyn ")?; + f.write_joined(bounds, " + ")?; + } + TypeRef::Macro(macro_call) => { + let macro_call = macro_call.to_node(f.db.upcast()); + let ctx = body::LowerCtx::with_hygiene(f.db.upcast(), &Hygiene::new_unhygienic()); + match macro_call.path() { + Some(path) => match Path::from_src(path, &ctx) { + Some(path) => path.hir_fmt(f)?, + None => write!(f, "{{macro}}")?, + }, + None => write!(f, "{{macro}}")?, + } + write!(f, "!(..)")?; + } + TypeRef::Error => write!(f, "{{error}}")?, + } + Ok(()) + } +} + +impl HirDisplay for TypeBound { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match self { + TypeBound::Path(path, modifier) => { + match modifier { + TraitBoundModifier::None => (), + TraitBoundModifier::Maybe => write!(f, "?")?, + } + path.hir_fmt(f) + } + TypeBound::Lifetime(lifetime) => write!(f, "{}", lifetime.name), + TypeBound::ForLifetime(lifetimes, path) => { + write!(f, "for<{}> ", lifetimes.iter().format(", "))?; + path.hir_fmt(f) + } + TypeBound::Error => write!(f, "{{error}}"), + } + } +} + +impl HirDisplay for Path { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match (self.type_anchor(), self.kind()) { + (Some(anchor), _) => { + write!(f, "<")?; + anchor.hir_fmt(f)?; + write!(f, ">")?; + } + (_, PathKind::Plain) => {} + (_, PathKind::Abs) => {} + (_, PathKind::Crate) => write!(f, "crate")?, + (_, PathKind::Super(0)) => write!(f, "self")?, + (_, PathKind::Super(n)) => { + for i in 0..*n { + if i > 0 { + write!(f, "::")?; + } + write!(f, "super")?; + } + } + (_, PathKind::DollarCrate(id)) => { + // Resolve `$crate` to the crate's display name. + // FIXME: should use the dependency name instead if available, but that depends on + // the crate invoking `HirDisplay` + let crate_graph = f.db.crate_graph(); + let name = crate_graph[*id] + .display_name + .as_ref() + .map(|name| name.canonical_name()) + .unwrap_or("$crate"); + write!(f, "{name}")? + } + } + + for (seg_idx, segment) in self.segments().iter().enumerate() { + if !matches!(self.kind(), PathKind::Plain) || seg_idx > 0 { + write!(f, "::")?; + } + write!(f, "{}", segment.name)?; + if let Some(generic_args) = segment.args_and_bindings { + // We should be in type context, so format as `Foo<Bar>` instead of `Foo::<Bar>`. + // Do we actually format expressions? + if generic_args.desugared_from_fn { + // First argument will be a tuple, which already includes the parentheses. + // If the tuple only contains 1 item, write it manually to avoid the trailing `,`. + if let hir_def::path::GenericArg::Type(TypeRef::Tuple(v)) = + &generic_args.args[0] + { + if v.len() == 1 { + write!(f, "(")?; + v[0].hir_fmt(f)?; + write!(f, ")")?; + } else { + generic_args.args[0].hir_fmt(f)?; + } + } + if let Some(ret) = &generic_args.bindings[0].type_ref { + if !matches!(ret, TypeRef::Tuple(v) if v.is_empty()) { + write!(f, " -> ")?; + ret.hir_fmt(f)?; + } + } + return Ok(()); + } + + write!(f, "<")?; + let mut first = true; + for arg in &generic_args.args { + if first { + first = false; + if generic_args.has_self_type { + // FIXME: Convert to `<Ty as Trait>` form. + write!(f, "Self = ")?; + } + } else { + write!(f, ", ")?; + } + arg.hir_fmt(f)?; + } + for binding in &generic_args.bindings { + if first { + first = false; + } else { + write!(f, ", ")?; + } + write!(f, "{}", binding.name)?; + match &binding.type_ref { + Some(ty) => { + write!(f, " = ")?; + ty.hir_fmt(f)? + } + None => { + write!(f, ": ")?; + f.write_joined(&binding.bounds, " + ")?; + } + } + } + write!(f, ">")?; + } + } + Ok(()) + } +} + +impl HirDisplay for hir_def::path::GenericArg { + fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> { + match self { + hir_def::path::GenericArg::Type(ty) => ty.hir_fmt(f), + hir_def::path::GenericArg::Const(c) => write!(f, "{}", c), + hir_def::path::GenericArg::Lifetime(lifetime) => write!(f, "{}", lifetime.name), + } + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs new file mode 100644 index 000000000..46eeea0e6 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs @@ -0,0 +1,1088 @@ +//! Type inference, i.e. the process of walking through the code and determining +//! the type of each expression and pattern. +//! +//! For type inference, compare the implementations in rustc (the various +//! check_* methods in librustc_typeck/check/mod.rs are a good entry point) and +//! IntelliJ-Rust (org.rust.lang.core.types.infer). Our entry point for +//! inference here is the `infer` function, which infers the types of all +//! expressions in a given function. +//! +//! During inference, types (i.e. the `Ty` struct) can contain type 'variables' +//! which represent currently unknown types; as we walk through the expressions, +//! we might determine that certain variables need to be equal to each other, or +//! to certain types. To record this, we use the union-find implementation from +//! the `ena` crate, which is extracted from rustc. + +use std::ops::Index; +use std::sync::Arc; + +use chalk_ir::{cast::Cast, ConstValue, DebruijnIndex, Mutability, Safety, Scalar, TypeFlags}; +use hir_def::{ + body::Body, + data::{ConstData, StaticData}, + expr::{BindingAnnotation, ExprId, PatId}, + lang_item::LangItemTarget, + path::{path, Path}, + resolver::{HasResolver, ResolveValueResult, Resolver, TypeNs, ValueNs}, + type_ref::TypeRef, + AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, HasModule, Lookup, + TraitId, TypeAliasId, VariantId, +}; +use hir_expand::name::{name, Name}; +use itertools::Either; +use la_arena::ArenaMap; +use rustc_hash::FxHashMap; +use stdx::{always, impl_from}; + +use crate::{ + db::HirDatabase, fold_tys, fold_tys_and_consts, infer::coerce::CoerceMany, + lower::ImplTraitLoweringMode, to_assoc_type_id, AliasEq, AliasTy, Const, DomainGoal, + GenericArg, Goal, ImplTraitId, InEnvironment, Interner, ProjectionTy, Substitution, + TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, +}; + +// This lint has a false positive here. See the link below for details. +// +// https://github.com/rust-lang/rust/issues/57411 +#[allow(unreachable_pub)] +pub use coerce::could_coerce; +#[allow(unreachable_pub)] +pub use unify::could_unify; + +pub(crate) mod unify; +mod path; +mod expr; +mod pat; +mod coerce; +mod closure; + +/// The entry point of type inference. +pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> { + let _p = profile::span("infer_query"); + let resolver = def.resolver(db.upcast()); + let body = db.body(def); + let mut ctx = InferenceContext::new(db, def, &body, resolver); + + match def { + DefWithBodyId::ConstId(c) => ctx.collect_const(&db.const_data(c)), + DefWithBodyId::FunctionId(f) => ctx.collect_fn(f), + DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_data(s)), + } + + ctx.infer_body(); + + Arc::new(ctx.resolve_all()) +} + +/// Fully normalize all the types found within `ty` in context of `owner` body definition. +/// +/// This is appropriate to use only after type-check: it assumes +/// that normalization will succeed, for example. +pub(crate) fn normalize(db: &dyn HirDatabase, owner: DefWithBodyId, ty: Ty) -> Ty { + if !ty.data(Interner).flags.intersects(TypeFlags::HAS_PROJECTION) { + return ty; + } + let krate = owner.module(db.upcast()).krate(); + let trait_env = owner + .as_generic_def_id() + .map_or_else(|| Arc::new(TraitEnvironment::empty(krate)), |d| db.trait_environment(d)); + let mut table = unify::InferenceTable::new(db, trait_env); + + let ty_with_vars = table.normalize_associated_types_in(ty); + table.resolve_obligations_as_possible(); + table.propagate_diverging_flag(); + table.resolve_completely(ty_with_vars) +} + +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +enum ExprOrPatId { + ExprId(ExprId), + PatId(PatId), +} +impl_from!(ExprId, PatId for ExprOrPatId); + +/// Binding modes inferred for patterns. +/// <https://doc.rust-lang.org/reference/patterns.html#binding-modes> +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum BindingMode { + Move, + Ref(Mutability), +} + +impl BindingMode { + fn convert(annotation: BindingAnnotation) -> BindingMode { + match annotation { + BindingAnnotation::Unannotated | BindingAnnotation::Mutable => BindingMode::Move, + BindingAnnotation::Ref => BindingMode::Ref(Mutability::Not), + BindingAnnotation::RefMut => BindingMode::Ref(Mutability::Mut), + } + } +} + +impl Default for BindingMode { + fn default() -> Self { + BindingMode::Move + } +} + +/// Used to generalize patterns and assignee expressions. +trait PatLike: Into<ExprOrPatId> + Copy { + type BindingMode: Copy; + + fn infer( + this: &mut InferenceContext<'_>, + id: Self, + expected_ty: &Ty, + default_bm: Self::BindingMode, + ) -> Ty; +} + +impl PatLike for ExprId { + type BindingMode = (); + + fn infer( + this: &mut InferenceContext<'_>, + id: Self, + expected_ty: &Ty, + _: Self::BindingMode, + ) -> Ty { + this.infer_assignee_expr(id, expected_ty) + } +} + +impl PatLike for PatId { + type BindingMode = BindingMode; + + fn infer( + this: &mut InferenceContext<'_>, + id: Self, + expected_ty: &Ty, + default_bm: Self::BindingMode, + ) -> Ty { + this.infer_pat(id, expected_ty, default_bm) + } +} + +#[derive(Debug)] +pub(crate) struct InferOk<T> { + value: T, + goals: Vec<InEnvironment<Goal>>, +} + +impl<T> InferOk<T> { + fn map<U>(self, f: impl FnOnce(T) -> U) -> InferOk<U> { + InferOk { value: f(self.value), goals: self.goals } + } +} + +#[derive(Debug)] +pub(crate) struct TypeError; +pub(crate) type InferResult<T> = Result<InferOk<T>, TypeError>; + +#[derive(Debug, PartialEq, Eq, Clone)] +pub enum InferenceDiagnostic { + NoSuchField { expr: ExprId }, + BreakOutsideOfLoop { expr: ExprId }, + MismatchedArgCount { call_expr: ExprId, expected: usize, found: usize }, +} + +/// A mismatch between an expected and an inferred type. +#[derive(Clone, PartialEq, Eq, Debug, Hash)] +pub struct TypeMismatch { + pub expected: Ty, + pub actual: Ty, +} + +#[derive(Clone, PartialEq, Eq, Debug)] +struct InternedStandardTypes { + unknown: Ty, + bool_: Ty, + unit: Ty, +} + +impl Default for InternedStandardTypes { + fn default() -> Self { + InternedStandardTypes { + unknown: TyKind::Error.intern(Interner), + bool_: TyKind::Scalar(Scalar::Bool).intern(Interner), + unit: TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner), + } + } +} +/// Represents coercing a value to a different type of value. +/// +/// We transform values by following a number of `Adjust` steps in order. +/// See the documentation on variants of `Adjust` for more details. +/// +/// Here are some common scenarios: +/// +/// 1. The simplest cases are where a pointer is not adjusted fat vs thin. +/// Here the pointer will be dereferenced N times (where a dereference can +/// happen to raw or borrowed pointers or any smart pointer which implements +/// Deref, including Box<_>). The types of dereferences is given by +/// `autoderefs`. It can then be auto-referenced zero or one times, indicated +/// by `autoref`, to either a raw or borrowed pointer. In these cases unsize is +/// `false`. +/// +/// 2. A thin-to-fat coercion involves unsizing the underlying data. We start +/// with a thin pointer, deref a number of times, unsize the underlying data, +/// then autoref. The 'unsize' phase may change a fixed length array to a +/// dynamically sized one, a concrete object to a trait object, or statically +/// sized struct to a dynamically sized one. E.g., &[i32; 4] -> &[i32] is +/// represented by: +/// +/// ``` +/// Deref(None) -> [i32; 4], +/// Borrow(AutoBorrow::Ref) -> &[i32; 4], +/// Unsize -> &[i32], +/// ``` +/// +/// Note that for a struct, the 'deep' unsizing of the struct is not recorded. +/// E.g., `struct Foo<T> { x: T }` we can coerce &Foo<[i32; 4]> to &Foo<[i32]> +/// The autoderef and -ref are the same as in the above example, but the type +/// stored in `unsize` is `Foo<[i32]>`, we don't store any further detail about +/// the underlying conversions from `[i32; 4]` to `[i32]`. +/// +/// 3. Coercing a `Box<T>` to `Box<dyn Trait>` is an interesting special case. In +/// that case, we have the pointer we need coming in, so there are no +/// autoderefs, and no autoref. Instead we just do the `Unsize` transformation. +/// At some point, of course, `Box` should move out of the compiler, in which +/// case this is analogous to transforming a struct. E.g., Box<[i32; 4]> -> +/// Box<[i32]> is an `Adjust::Unsize` with the target `Box<[i32]>`. +#[derive(Clone, Debug, PartialEq, Eq, Hash)] +pub struct Adjustment { + pub kind: Adjust, + pub target: Ty, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum Adjust { + /// Go from ! to any type. + NeverToAny, + /// Dereference once, producing a place. + Deref(Option<OverloadedDeref>), + /// Take the address and produce either a `&` or `*` pointer. + Borrow(AutoBorrow), + Pointer(PointerCast), +} + +/// An overloaded autoderef step, representing a `Deref(Mut)::deref(_mut)` +/// call, with the signature `&'a T -> &'a U` or `&'a mut T -> &'a mut U`. +/// The target type is `U` in both cases, with the region and mutability +/// being those shared by both the receiver and the returned reference. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct OverloadedDeref(pub Mutability); + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum AutoBorrow { + /// Converts from T to &T. + Ref(Mutability), + /// Converts from T to *T. + RawPtr(Mutability), +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum PointerCast { + /// Go from a fn-item type to a fn-pointer type. + ReifyFnPointer, + + /// Go from a safe fn pointer to an unsafe fn pointer. + UnsafeFnPointer, + + /// Go from a non-capturing closure to an fn pointer or an unsafe fn pointer. + /// It cannot convert a closure that requires unsafe. + ClosureFnPointer(Safety), + + /// Go from a mut raw pointer to a const raw pointer. + MutToConstPointer, + + #[allow(dead_code)] + /// Go from `*const [T; N]` to `*const T` + ArrayToPointer, + + /// Unsize a pointer/reference value, e.g., `&[T; n]` to + /// `&[T]`. Note that the source could be a thin or fat pointer. + /// This will do things like convert thin pointers to fat + /// pointers, or convert structs containing thin pointers to + /// structs containing fat pointers, or convert between fat + /// pointers. We don't store the details of how the transform is + /// done (in fact, we don't know that, because it might depend on + /// the precise type parameters). We just store the target + /// type. Codegen backends and miri figure out what has to be done + /// based on the precise source/target type at hand. + Unsize, +} + +/// The result of type inference: A mapping from expressions and patterns to types. +#[derive(Clone, PartialEq, Eq, Debug, Default)] +pub struct InferenceResult { + /// For each method call expr, records the function it resolves to. + method_resolutions: FxHashMap<ExprId, (FunctionId, Substitution)>, + /// For each field access expr, records the field it resolves to. + field_resolutions: FxHashMap<ExprId, FieldId>, + /// For each struct literal or pattern, records the variant it resolves to. + variant_resolutions: FxHashMap<ExprOrPatId, VariantId>, + /// For each associated item record what it resolves to + assoc_resolutions: FxHashMap<ExprOrPatId, AssocItemId>, + pub diagnostics: Vec<InferenceDiagnostic>, + pub type_of_expr: ArenaMap<ExprId, Ty>, + /// For each pattern record the type it resolves to. + /// + /// **Note**: When a pattern type is resolved it may still contain + /// unresolved or missing subpatterns or subpatterns of mismatched types. + pub type_of_pat: ArenaMap<PatId, Ty>, + type_mismatches: FxHashMap<ExprOrPatId, TypeMismatch>, + /// Interned Unknown to return references to. + standard_types: InternedStandardTypes, + /// Stores the types which were implicitly dereferenced in pattern binding modes. + pub pat_adjustments: FxHashMap<PatId, Vec<Ty>>, + pub pat_binding_modes: FxHashMap<PatId, BindingMode>, + pub expr_adjustments: FxHashMap<ExprId, Vec<Adjustment>>, +} + +impl InferenceResult { + pub fn method_resolution(&self, expr: ExprId) -> Option<(FunctionId, Substitution)> { + self.method_resolutions.get(&expr).cloned() + } + pub fn field_resolution(&self, expr: ExprId) -> Option<FieldId> { + self.field_resolutions.get(&expr).copied() + } + pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId> { + self.variant_resolutions.get(&id.into()).copied() + } + pub fn variant_resolution_for_pat(&self, id: PatId) -> Option<VariantId> { + self.variant_resolutions.get(&id.into()).copied() + } + pub fn assoc_resolutions_for_expr(&self, id: ExprId) -> Option<AssocItemId> { + self.assoc_resolutions.get(&id.into()).copied() + } + pub fn assoc_resolutions_for_pat(&self, id: PatId) -> Option<AssocItemId> { + self.assoc_resolutions.get(&id.into()).copied() + } + pub fn type_mismatch_for_expr(&self, expr: ExprId) -> Option<&TypeMismatch> { + self.type_mismatches.get(&expr.into()) + } + pub fn type_mismatch_for_pat(&self, pat: PatId) -> Option<&TypeMismatch> { + self.type_mismatches.get(&pat.into()) + } + pub fn expr_type_mismatches(&self) -> impl Iterator<Item = (ExprId, &TypeMismatch)> { + self.type_mismatches.iter().filter_map(|(expr_or_pat, mismatch)| match *expr_or_pat { + ExprOrPatId::ExprId(expr) => Some((expr, mismatch)), + _ => None, + }) + } + pub fn pat_type_mismatches(&self) -> impl Iterator<Item = (PatId, &TypeMismatch)> { + self.type_mismatches.iter().filter_map(|(expr_or_pat, mismatch)| match *expr_or_pat { + ExprOrPatId::PatId(pat) => Some((pat, mismatch)), + _ => None, + }) + } +} + +impl Index<ExprId> for InferenceResult { + type Output = Ty; + + fn index(&self, expr: ExprId) -> &Ty { + self.type_of_expr.get(expr).unwrap_or(&self.standard_types.unknown) + } +} + +impl Index<PatId> for InferenceResult { + type Output = Ty; + + fn index(&self, pat: PatId) -> &Ty { + self.type_of_pat.get(pat).unwrap_or(&self.standard_types.unknown) + } +} + +/// The inference context contains all information needed during type inference. +#[derive(Clone, Debug)] +pub(crate) struct InferenceContext<'a> { + pub(crate) db: &'a dyn HirDatabase, + pub(crate) owner: DefWithBodyId, + pub(crate) body: &'a Body, + pub(crate) resolver: Resolver, + table: unify::InferenceTable<'a>, + trait_env: Arc<TraitEnvironment>, + pub(crate) result: InferenceResult, + /// The return type of the function being inferred, the closure or async block if we're + /// currently within one. + /// + /// We might consider using a nested inference context for checking + /// closures, but currently this is the only field that will change there, + /// so it doesn't make sense. + return_ty: Ty, + diverges: Diverges, + breakables: Vec<BreakableContext>, +} + +#[derive(Clone, Debug)] +struct BreakableContext { + may_break: bool, + coerce: CoerceMany, + label: Option<name::Name>, +} + +fn find_breakable<'c>( + ctxs: &'c mut [BreakableContext], + label: Option<&name::Name>, +) -> Option<&'c mut BreakableContext> { + match label { + Some(_) => ctxs.iter_mut().rev().find(|ctx| ctx.label.as_ref() == label), + None => ctxs.last_mut(), + } +} + +impl<'a> InferenceContext<'a> { + fn new( + db: &'a dyn HirDatabase, + owner: DefWithBodyId, + body: &'a Body, + resolver: Resolver, + ) -> Self { + let krate = owner.module(db.upcast()).krate(); + let trait_env = owner + .as_generic_def_id() + .map_or_else(|| Arc::new(TraitEnvironment::empty(krate)), |d| db.trait_environment(d)); + InferenceContext { + result: InferenceResult::default(), + table: unify::InferenceTable::new(db, trait_env.clone()), + trait_env, + return_ty: TyKind::Error.intern(Interner), // set in collect_fn_signature + db, + owner, + body, + resolver, + diverges: Diverges::Maybe, + breakables: Vec::new(), + } + } + + fn resolve_all(self) -> InferenceResult { + let InferenceContext { mut table, mut result, .. } = self; + + // FIXME resolve obligations as well (use Guidance if necessary) + table.resolve_obligations_as_possible(); + + // make sure diverging type variables are marked as such + table.propagate_diverging_flag(); + for ty in result.type_of_expr.values_mut() { + *ty = table.resolve_completely(ty.clone()); + } + for ty in result.type_of_pat.values_mut() { + *ty = table.resolve_completely(ty.clone()); + } + for mismatch in result.type_mismatches.values_mut() { + mismatch.expected = table.resolve_completely(mismatch.expected.clone()); + mismatch.actual = table.resolve_completely(mismatch.actual.clone()); + } + for (_, subst) in result.method_resolutions.values_mut() { + *subst = table.resolve_completely(subst.clone()); + } + for adjustment in result.expr_adjustments.values_mut().flatten() { + adjustment.target = table.resolve_completely(adjustment.target.clone()); + } + for adjustment in result.pat_adjustments.values_mut().flatten() { + *adjustment = table.resolve_completely(adjustment.clone()); + } + result + } + + fn collect_const(&mut self, data: &ConstData) { + self.return_ty = self.make_ty(&data.type_ref); + } + + fn collect_static(&mut self, data: &StaticData) { + self.return_ty = self.make_ty(&data.type_ref); + } + + fn collect_fn(&mut self, func: FunctionId) { + let data = self.db.function_data(func); + let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver) + .with_impl_trait_mode(ImplTraitLoweringMode::Param); + let param_tys = + data.params.iter().map(|(_, type_ref)| ctx.lower_ty(type_ref)).collect::<Vec<_>>(); + for (ty, pat) in param_tys.into_iter().zip(self.body.params.iter()) { + let ty = self.insert_type_vars(ty); + let ty = self.normalize_associated_types_in(ty); + + self.infer_pat(*pat, &ty, BindingMode::default()); + } + let error_ty = &TypeRef::Error; + let return_ty = if data.has_async_kw() { + data.async_ret_type.as_deref().unwrap_or(error_ty) + } else { + &*data.ret_type + }; + let return_ty = self.make_ty_with_mode(return_ty, ImplTraitLoweringMode::Opaque); + self.return_ty = return_ty; + + if let Some(rpits) = self.db.return_type_impl_traits(func) { + // RPIT opaque types use substitution of their parent function. + let fn_placeholders = TyBuilder::placeholder_subst(self.db, func); + self.return_ty = fold_tys( + self.return_ty.clone(), + |ty, _| { + let opaque_ty_id = match ty.kind(Interner) { + TyKind::OpaqueType(opaque_ty_id, _) => *opaque_ty_id, + _ => return ty, + }; + let idx = match self.db.lookup_intern_impl_trait_id(opaque_ty_id.into()) { + ImplTraitId::ReturnTypeImplTrait(_, idx) => idx, + _ => unreachable!(), + }; + let bounds = (*rpits).map_ref(|rpits| { + rpits.impl_traits[idx as usize].bounds.map_ref(|it| it.into_iter()) + }); + let var = self.table.new_type_var(); + let var_subst = Substitution::from1(Interner, var.clone()); + for bound in bounds { + let predicate = + bound.map(|it| it.cloned()).substitute(Interner, &fn_placeholders); + let (var_predicate, binders) = predicate + .substitute(Interner, &var_subst) + .into_value_and_skipped_binders(); + always!(binders.len(Interner) == 0); // quantified where clauses not yet handled + self.push_obligation(var_predicate.cast(Interner)); + } + var + }, + DebruijnIndex::INNERMOST, + ); + } + } + + fn infer_body(&mut self) { + self.infer_expr_coerce(self.body.body_expr, &Expectation::has_type(self.return_ty.clone())); + } + + fn write_expr_ty(&mut self, expr: ExprId, ty: Ty) { + self.result.type_of_expr.insert(expr, ty); + } + + fn write_expr_adj(&mut self, expr: ExprId, adjustments: Vec<Adjustment>) { + self.result.expr_adjustments.insert(expr, adjustments); + } + + fn write_method_resolution(&mut self, expr: ExprId, func: FunctionId, subst: Substitution) { + self.result.method_resolutions.insert(expr, (func, subst)); + } + + fn write_variant_resolution(&mut self, id: ExprOrPatId, variant: VariantId) { + self.result.variant_resolutions.insert(id, variant); + } + + fn write_assoc_resolution(&mut self, id: ExprOrPatId, item: AssocItemId) { + self.result.assoc_resolutions.insert(id, item); + } + + fn write_pat_ty(&mut self, pat: PatId, ty: Ty) { + self.result.type_of_pat.insert(pat, ty); + } + + fn push_diagnostic(&mut self, diagnostic: InferenceDiagnostic) { + self.result.diagnostics.push(diagnostic); + } + + fn make_ty_with_mode( + &mut self, + type_ref: &TypeRef, + impl_trait_mode: ImplTraitLoweringMode, + ) -> Ty { + // FIXME use right resolver for block + let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver) + .with_impl_trait_mode(impl_trait_mode); + let ty = ctx.lower_ty(type_ref); + let ty = self.insert_type_vars(ty); + self.normalize_associated_types_in(ty) + } + + fn make_ty(&mut self, type_ref: &TypeRef) -> Ty { + self.make_ty_with_mode(type_ref, ImplTraitLoweringMode::Disallowed) + } + + fn err_ty(&self) -> Ty { + self.result.standard_types.unknown.clone() + } + + /// Replaces ConstScalar::Unknown by a new type var, so we can maybe still infer it. + fn insert_const_vars_shallow(&mut self, c: Const) -> Const { + let data = c.data(Interner); + match data.value { + ConstValue::Concrete(cc) => match cc.interned { + hir_def::type_ref::ConstScalar::Unknown => { + self.table.new_const_var(data.ty.clone()) + } + _ => c, + }, + _ => c, + } + } + + /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it. + fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty { + match ty.kind(Interner) { + TyKind::Error => self.table.new_type_var(), + TyKind::InferenceVar(..) => { + let ty_resolved = self.resolve_ty_shallow(&ty); + if ty_resolved.is_unknown() { + self.table.new_type_var() + } else { + ty + } + } + _ => ty, + } + } + + fn insert_type_vars(&mut self, ty: Ty) -> Ty { + fold_tys_and_consts( + ty, + |x, _| match x { + Either::Left(ty) => Either::Left(self.insert_type_vars_shallow(ty)), + Either::Right(c) => Either::Right(self.insert_const_vars_shallow(c)), + }, + DebruijnIndex::INNERMOST, + ) + } + + fn resolve_obligations_as_possible(&mut self) { + self.table.resolve_obligations_as_possible(); + } + + fn push_obligation(&mut self, o: DomainGoal) { + self.table.register_obligation(o.cast(Interner)); + } + + fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool { + self.table.unify(ty1, ty2) + } + + /// Recurses through the given type, normalizing associated types mentioned + /// in it by replacing them by type variables and registering obligations to + /// resolve later. This should be done once for every type we get from some + /// type annotation (e.g. from a let type annotation, field type or function + /// call). `make_ty` handles this already, but e.g. for field types we need + /// to do it as well. + fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty { + self.table.normalize_associated_types_in(ty) + } + + fn resolve_ty_shallow(&mut self, ty: &Ty) -> Ty { + self.resolve_obligations_as_possible(); + self.table.resolve_ty_shallow(ty) + } + + fn resolve_associated_type(&mut self, inner_ty: Ty, assoc_ty: Option<TypeAliasId>) -> Ty { + self.resolve_associated_type_with_params(inner_ty, assoc_ty, &[]) + } + + fn resolve_associated_type_with_params( + &mut self, + inner_ty: Ty, + assoc_ty: Option<TypeAliasId>, + params: &[GenericArg], + ) -> Ty { + match assoc_ty { + Some(res_assoc_ty) => { + let trait_ = match res_assoc_ty.lookup(self.db.upcast()).container { + hir_def::ItemContainerId::TraitId(trait_) => trait_, + _ => panic!("resolve_associated_type called with non-associated type"), + }; + let ty = self.table.new_type_var(); + let mut param_iter = params.iter().cloned(); + let trait_ref = TyBuilder::trait_ref(self.db, trait_) + .push(inner_ty) + .fill(|_| param_iter.next().unwrap()) + .build(); + let alias_eq = AliasEq { + alias: AliasTy::Projection(ProjectionTy { + associated_ty_id: to_assoc_type_id(res_assoc_ty), + substitution: trait_ref.substitution.clone(), + }), + ty: ty.clone(), + }; + self.push_obligation(trait_ref.cast(Interner)); + self.push_obligation(alias_eq.cast(Interner)); + ty + } + None => self.err_ty(), + } + } + + fn resolve_variant(&mut self, path: Option<&Path>, value_ns: bool) -> (Ty, Option<VariantId>) { + let path = match path { + Some(path) => path, + None => return (self.err_ty(), None), + }; + let resolver = &self.resolver; + let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); + // FIXME: this should resolve assoc items as well, see this example: + // https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521 + let (resolution, unresolved) = if value_ns { + match resolver.resolve_path_in_value_ns(self.db.upcast(), path.mod_path()) { + Some(ResolveValueResult::ValueNs(value)) => match value { + ValueNs::EnumVariantId(var) => { + let substs = ctx.substs_from_path(path, var.into(), true); + let ty = self.db.ty(var.parent.into()); + let ty = self.insert_type_vars(ty.substitute(Interner, &substs)); + return (ty, Some(var.into())); + } + ValueNs::StructId(strukt) => { + let substs = ctx.substs_from_path(path, strukt.into(), true); + let ty = self.db.ty(strukt.into()); + let ty = self.insert_type_vars(ty.substitute(Interner, &substs)); + return (ty, Some(strukt.into())); + } + _ => return (self.err_ty(), None), + }, + Some(ResolveValueResult::Partial(typens, unresolved)) => (typens, Some(unresolved)), + None => return (self.err_ty(), None), + } + } else { + match resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { + Some(it) => it, + None => return (self.err_ty(), None), + } + }; + return match resolution { + TypeNs::AdtId(AdtId::StructId(strukt)) => { + let substs = ctx.substs_from_path(path, strukt.into(), true); + let ty = self.db.ty(strukt.into()); + let ty = self.insert_type_vars(ty.substitute(Interner, &substs)); + forbid_unresolved_segments((ty, Some(strukt.into())), unresolved) + } + TypeNs::AdtId(AdtId::UnionId(u)) => { + let substs = ctx.substs_from_path(path, u.into(), true); + let ty = self.db.ty(u.into()); + let ty = self.insert_type_vars(ty.substitute(Interner, &substs)); + forbid_unresolved_segments((ty, Some(u.into())), unresolved) + } + TypeNs::EnumVariantId(var) => { + let substs = ctx.substs_from_path(path, var.into(), true); + let ty = self.db.ty(var.parent.into()); + let ty = self.insert_type_vars(ty.substitute(Interner, &substs)); + forbid_unresolved_segments((ty, Some(var.into())), unresolved) + } + TypeNs::SelfType(impl_id) => { + let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); + let substs = generics.placeholder_subst(self.db); + let ty = self.db.impl_self_ty(impl_id).substitute(Interner, &substs); + self.resolve_variant_on_alias(ty, unresolved, path) + } + TypeNs::TypeAliasId(it) => { + let ty = TyBuilder::def_ty(self.db, it.into()) + .fill_with_inference_vars(&mut self.table) + .build(); + self.resolve_variant_on_alias(ty, unresolved, path) + } + TypeNs::AdtSelfType(_) => { + // FIXME this could happen in array size expressions, once we're checking them + (self.err_ty(), None) + } + TypeNs::GenericParam(_) => { + // FIXME potentially resolve assoc type + (self.err_ty(), None) + } + TypeNs::AdtId(AdtId::EnumId(_)) | TypeNs::BuiltinType(_) | TypeNs::TraitId(_) => { + // FIXME diagnostic + (self.err_ty(), None) + } + }; + + fn forbid_unresolved_segments( + result: (Ty, Option<VariantId>), + unresolved: Option<usize>, + ) -> (Ty, Option<VariantId>) { + if unresolved.is_none() { + result + } else { + // FIXME diagnostic + (TyKind::Error.intern(Interner), None) + } + } + } + + fn resolve_variant_on_alias( + &mut self, + ty: Ty, + unresolved: Option<usize>, + path: &Path, + ) -> (Ty, Option<VariantId>) { + let remaining = unresolved.map(|x| path.segments().skip(x).len()).filter(|x| x > &0); + match remaining { + None => { + let variant = ty.as_adt().and_then(|(adt_id, _)| match adt_id { + AdtId::StructId(s) => Some(VariantId::StructId(s)), + AdtId::UnionId(u) => Some(VariantId::UnionId(u)), + AdtId::EnumId(_) => { + // FIXME Error E0071, expected struct, variant or union type, found enum `Foo` + None + } + }); + (ty, variant) + } + Some(1) => { + let segment = path.mod_path().segments().last().unwrap(); + // this could be an enum variant or associated type + if let Some((AdtId::EnumId(enum_id), _)) = ty.as_adt() { + let enum_data = self.db.enum_data(enum_id); + if let Some(local_id) = enum_data.variant(segment) { + let variant = EnumVariantId { parent: enum_id, local_id }; + return (ty, Some(variant.into())); + } + } + // FIXME potentially resolve assoc type + (self.err_ty(), None) + } + Some(_) => { + // FIXME diagnostic + (self.err_ty(), None) + } + } + } + + fn resolve_lang_item(&self, name: Name) -> Option<LangItemTarget> { + let krate = self.resolver.krate(); + self.db.lang_item(krate, name.to_smol_str()) + } + + fn resolve_into_iter_item(&self) -> Option<TypeAliasId> { + let path = path![core::iter::IntoIterator]; + let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?; + self.db.trait_data(trait_).associated_type_by_name(&name![Item]) + } + + fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> { + // FIXME resolve via lang_item once try v2 is stable + let path = path![core::ops::Try]; + let trait_ = self.resolver.resolve_known_trait(self.db.upcast(), &path)?; + let trait_data = self.db.trait_data(trait_); + trait_data + // FIXME remove once try v2 is stable + .associated_type_by_name(&name![Ok]) + .or_else(|| trait_data.associated_type_by_name(&name![Output])) + } + + fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> { + let trait_ = self.resolve_lang_item(name![neg])?.as_trait()?; + self.db.trait_data(trait_).associated_type_by_name(&name![Output]) + } + + fn resolve_ops_not_output(&self) -> Option<TypeAliasId> { + let trait_ = self.resolve_lang_item(name![not])?.as_trait()?; + self.db.trait_data(trait_).associated_type_by_name(&name![Output]) + } + + fn resolve_future_future_output(&self) -> Option<TypeAliasId> { + let trait_ = self.resolve_lang_item(name![future_trait])?.as_trait()?; + self.db.trait_data(trait_).associated_type_by_name(&name![Output]) + } + + fn resolve_boxed_box(&self) -> Option<AdtId> { + let struct_ = self.resolve_lang_item(name![owned_box])?.as_struct()?; + Some(struct_.into()) + } + + fn resolve_range_full(&self) -> Option<AdtId> { + let path = path![core::ops::RangeFull]; + let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?; + Some(struct_.into()) + } + + fn resolve_range(&self) -> Option<AdtId> { + let path = path![core::ops::Range]; + let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?; + Some(struct_.into()) + } + + fn resolve_range_inclusive(&self) -> Option<AdtId> { + let path = path![core::ops::RangeInclusive]; + let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?; + Some(struct_.into()) + } + + fn resolve_range_from(&self) -> Option<AdtId> { + let path = path![core::ops::RangeFrom]; + let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?; + Some(struct_.into()) + } + + fn resolve_range_to(&self) -> Option<AdtId> { + let path = path![core::ops::RangeTo]; + let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?; + Some(struct_.into()) + } + + fn resolve_range_to_inclusive(&self) -> Option<AdtId> { + let path = path![core::ops::RangeToInclusive]; + let struct_ = self.resolver.resolve_known_struct(self.db.upcast(), &path)?; + Some(struct_.into()) + } + + fn resolve_ops_index(&self) -> Option<TraitId> { + self.resolve_lang_item(name![index])?.as_trait() + } + + fn resolve_ops_index_output(&self) -> Option<TypeAliasId> { + let trait_ = self.resolve_ops_index()?; + self.db.trait_data(trait_).associated_type_by_name(&name![Output]) + } +} + +/// When inferring an expression, we propagate downward whatever type hint we +/// are able in the form of an `Expectation`. +#[derive(Clone, PartialEq, Eq, Debug)] +pub(crate) enum Expectation { + None, + HasType(Ty), + // Castable(Ty), // rustc has this, we currently just don't propagate an expectation for casts + RValueLikeUnsized(Ty), +} + +impl Expectation { + /// The expectation that the type of the expression needs to equal the given + /// type. + fn has_type(ty: Ty) -> Self { + if ty.is_unknown() { + // FIXME: get rid of this? + Expectation::None + } else { + Expectation::HasType(ty) + } + } + + fn from_option(ty: Option<Ty>) -> Self { + ty.map_or(Expectation::None, Expectation::HasType) + } + + /// The following explanation is copied straight from rustc: + /// Provides an expectation for an rvalue expression given an *optional* + /// hint, which is not required for type safety (the resulting type might + /// be checked higher up, as is the case with `&expr` and `box expr`), but + /// is useful in determining the concrete type. + /// + /// The primary use case is where the expected type is a fat pointer, + /// like `&[isize]`. For example, consider the following statement: + /// + /// let x: &[isize] = &[1, 2, 3]; + /// + /// In this case, the expected type for the `&[1, 2, 3]` expression is + /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the + /// expectation `ExpectHasType([isize])`, that would be too strong -- + /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`. + /// It is only the `&[1, 2, 3]` expression as a whole that can be coerced + /// to the type `&[isize]`. Therefore, we propagate this more limited hint, + /// which still is useful, because it informs integer literals and the like. + /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169 + /// for examples of where this comes up,. + fn rvalue_hint(table: &mut unify::InferenceTable<'_>, ty: Ty) -> Self { + // FIXME: do struct_tail_without_normalization + match table.resolve_ty_shallow(&ty).kind(Interner) { + TyKind::Slice(_) | TyKind::Str | TyKind::Dyn(_) => Expectation::RValueLikeUnsized(ty), + _ => Expectation::has_type(ty), + } + } + + /// This expresses no expectation on the type. + fn none() -> Self { + Expectation::None + } + + fn resolve(&self, table: &mut unify::InferenceTable<'_>) -> Expectation { + match self { + Expectation::None => Expectation::None, + Expectation::HasType(t) => Expectation::HasType(table.resolve_ty_shallow(t)), + Expectation::RValueLikeUnsized(t) => { + Expectation::RValueLikeUnsized(table.resolve_ty_shallow(t)) + } + } + } + + fn to_option(&self, table: &mut unify::InferenceTable<'_>) -> Option<Ty> { + match self.resolve(table) { + Expectation::None => None, + Expectation::HasType(t) | + // Expectation::Castable(t) | + Expectation::RValueLikeUnsized(t) => Some(t), + } + } + + fn only_has_type(&self, table: &mut unify::InferenceTable<'_>) -> Option<Ty> { + match self { + Expectation::HasType(t) => Some(table.resolve_ty_shallow(t)), + // Expectation::Castable(_) | + Expectation::RValueLikeUnsized(_) | Expectation::None => None, + } + } + + /// Comment copied from rustc: + /// Disregard "castable to" expectations because they + /// can lead us astray. Consider for example `if cond + /// {22} else {c} as u8` -- if we propagate the + /// "castable to u8" constraint to 22, it will pick the + /// type 22u8, which is overly constrained (c might not + /// be a u8). In effect, the problem is that the + /// "castable to" expectation is not the tightest thing + /// we can say, so we want to drop it in this case. + /// The tightest thing we can say is "must unify with + /// else branch". Note that in the case of a "has type" + /// constraint, this limitation does not hold. + /// + /// If the expected type is just a type variable, then don't use + /// an expected type. Otherwise, we might write parts of the type + /// when checking the 'then' block which are incompatible with the + /// 'else' branch. + fn adjust_for_branches(&self, table: &mut unify::InferenceTable<'_>) -> Expectation { + match self { + Expectation::HasType(ety) => { + let ety = table.resolve_ty_shallow(ety); + if !ety.is_ty_var() { + Expectation::HasType(ety) + } else { + Expectation::None + } + } + Expectation::RValueLikeUnsized(ety) => Expectation::RValueLikeUnsized(ety.clone()), + _ => Expectation::None, + } + } +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +enum Diverges { + Maybe, + Always, +} + +impl Diverges { + fn is_always(self) -> bool { + self == Diverges::Always + } +} + +impl std::ops::BitAnd for Diverges { + type Output = Self; + fn bitand(self, other: Self) -> Self { + std::cmp::min(self, other) + } +} + +impl std::ops::BitOr for Diverges { + type Output = Self; + fn bitor(self, other: Self) -> Self { + std::cmp::max(self, other) + } +} + +impl std::ops::BitAndAssign for Diverges { + fn bitand_assign(&mut self, other: Self) { + *self = *self & other; + } +} + +impl std::ops::BitOrAssign for Diverges { + fn bitor_assign(&mut self, other: Self) { + *self = *self | other; + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs new file mode 100644 index 000000000..3ead92909 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs @@ -0,0 +1,82 @@ +//! Inference of closure parameter types based on the closure's expected type. + +use chalk_ir::{cast::Cast, AliasEq, AliasTy, FnSubst, WhereClause}; +use hir_def::{expr::ExprId, HasModule}; +use smallvec::SmallVec; + +use crate::{ + to_chalk_trait_id, utils, ChalkTraitId, DynTy, FnPointer, FnSig, Interner, Substitution, Ty, + TyExt, TyKind, +}; + +use super::{Expectation, InferenceContext}; + +impl InferenceContext<'_> { + pub(super) fn deduce_closure_type_from_expectations( + &mut self, + closure_expr: ExprId, + closure_ty: &Ty, + sig_ty: &Ty, + expectation: &Expectation, + ) { + let expected_ty = match expectation.to_option(&mut self.table) { + Some(ty) => ty, + None => return, + }; + + // Deduction from where-clauses in scope, as well as fn-pointer coercion are handled here. + let _ = self.coerce(Some(closure_expr), closure_ty, &expected_ty); + + // Deduction based on the expected `dyn Fn` is done separately. + if let TyKind::Dyn(dyn_ty) = expected_ty.kind(Interner) { + if let Some(sig) = self.deduce_sig_from_dyn_ty(dyn_ty) { + let expected_sig_ty = TyKind::Function(sig).intern(Interner); + + self.unify(sig_ty, &expected_sig_ty); + } + } + } + + fn deduce_sig_from_dyn_ty(&self, dyn_ty: &DynTy) -> Option<FnPointer> { + // Search for a predicate like `<$self as FnX<Args>>::Output == Ret` + + let fn_traits: SmallVec<[ChalkTraitId; 3]> = + utils::fn_traits(self.db.upcast(), self.owner.module(self.db.upcast()).krate()) + .map(to_chalk_trait_id) + .collect(); + + let self_ty = TyKind::Error.intern(Interner); + let bounds = dyn_ty.bounds.clone().substitute(Interner, &[self_ty.cast(Interner)]); + for bound in bounds.iter(Interner) { + // NOTE(skip_binders): the extracted types are rebound by the returned `FnPointer` + if let WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection), ty }) = + bound.skip_binders() + { + let assoc_data = self.db.associated_ty_data(projection.associated_ty_id); + if !fn_traits.contains(&assoc_data.trait_id) { + return None; + } + + // Skip `Self`, get the type argument. + let arg = projection.substitution.as_slice(Interner).get(1)?; + if let Some(subst) = arg.ty(Interner)?.as_tuple() { + let generic_args = subst.as_slice(Interner); + let mut sig_tys = Vec::new(); + for arg in generic_args { + sig_tys.push(arg.ty(Interner)?.clone()); + } + sig_tys.push(ty.clone()); + + cov_mark::hit!(dyn_fn_param_informs_call_site_closure_signature); + return Some(FnPointer { + num_binders: bound.len(Interner), + sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false }, + substitution: FnSubst(Substitution::from_iter(Interner, sig_tys)), + }); + } + } + } + + None + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs new file mode 100644 index 000000000..f54440bf5 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs @@ -0,0 +1,673 @@ +//! Coercion logic. Coercions are certain type conversions that can implicitly +//! happen in certain places, e.g. weakening `&mut` to `&` or deref coercions +//! like going from `&Vec<T>` to `&[T]`. +//! +//! See <https://doc.rust-lang.org/nomicon/coercions.html> and +//! `librustc_typeck/check/coercion.rs`. + +use std::{iter, sync::Arc}; + +use chalk_ir::{cast::Cast, BoundVar, Goal, Mutability, TyVariableKind}; +use hir_def::{expr::ExprId, lang_item::LangItemTarget}; +use stdx::always; +use syntax::SmolStr; + +use crate::{ + autoderef::{Autoderef, AutoderefKind}, + db::HirDatabase, + infer::{ + Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast, + TypeError, TypeMismatch, + }, + static_lifetime, Canonical, DomainGoal, FnPointer, FnSig, Guidance, InEnvironment, Interner, + Solution, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind, +}; + +use super::unify::InferenceTable; + +pub(crate) type CoerceResult = Result<InferOk<(Vec<Adjustment>, Ty)>, TypeError>; + +/// Do not require any adjustments, i.e. coerce `x -> x`. +fn identity(_: Ty) -> Vec<Adjustment> { + vec![] +} + +fn simple(kind: Adjust) -> impl FnOnce(Ty) -> Vec<Adjustment> { + move |target| vec![Adjustment { kind, target }] +} + +/// This always returns `Ok(...)`. +fn success( + adj: Vec<Adjustment>, + target: Ty, + goals: Vec<InEnvironment<Goal<Interner>>>, +) -> CoerceResult { + Ok(InferOk { goals, value: (adj, target) }) +} + +#[derive(Clone, Debug)] +pub(super) struct CoerceMany { + expected_ty: Ty, +} + +impl CoerceMany { + pub(super) fn new(expected: Ty) -> Self { + CoerceMany { expected_ty: expected } + } + + /// Merge two types from different branches, with possible coercion. + /// + /// Mostly this means trying to coerce one to the other, but + /// - if we have two function types for different functions or closures, we need to + /// coerce both to function pointers; + /// - if we were concerned with lifetime subtyping, we'd need to look for a + /// least upper bound. + pub(super) fn coerce( + &mut self, + ctx: &mut InferenceContext<'_>, + expr: Option<ExprId>, + expr_ty: &Ty, + ) { + let expr_ty = ctx.resolve_ty_shallow(expr_ty); + self.expected_ty = ctx.resolve_ty_shallow(&self.expected_ty); + + // Special case: two function types. Try to coerce both to + // pointers to have a chance at getting a match. See + // https://github.com/rust-lang/rust/blob/7b805396bf46dce972692a6846ce2ad8481c5f85/src/librustc_typeck/check/coercion.rs#L877-L916 + let sig = match (self.expected_ty.kind(Interner), expr_ty.kind(Interner)) { + (TyKind::FnDef(..) | TyKind::Closure(..), TyKind::FnDef(..) | TyKind::Closure(..)) => { + // FIXME: we're ignoring safety here. To be more correct, if we have one FnDef and one Closure, + // we should be coercing the closure to a fn pointer of the safety of the FnDef + cov_mark::hit!(coerce_fn_reification); + let sig = + self.expected_ty.callable_sig(ctx.db).expect("FnDef without callable sig"); + Some(sig) + } + _ => None, + }; + if let Some(sig) = sig { + let target_ty = TyKind::Function(sig.to_fn_ptr()).intern(Interner); + let result1 = ctx.table.coerce_inner(self.expected_ty.clone(), &target_ty); + let result2 = ctx.table.coerce_inner(expr_ty.clone(), &target_ty); + if let (Ok(result1), Ok(result2)) = (result1, result2) { + ctx.table.register_infer_ok(result1); + ctx.table.register_infer_ok(result2); + return self.expected_ty = target_ty; + } + } + + // It might not seem like it, but order is important here: If the expected + // type is a type variable and the new one is `!`, trying it the other + // way around first would mean we make the type variable `!`, instead of + // just marking it as possibly diverging. + if ctx.coerce(expr, &expr_ty, &self.expected_ty).is_ok() { + /* self.expected_ty is already correct */ + } else if ctx.coerce(expr, &self.expected_ty, &expr_ty).is_ok() { + self.expected_ty = expr_ty; + } else { + if let Some(id) = expr { + ctx.result.type_mismatches.insert( + id.into(), + TypeMismatch { expected: self.expected_ty.clone(), actual: expr_ty }, + ); + } + cov_mark::hit!(coerce_merge_fail_fallback); + /* self.expected_ty is already correct */ + } + } + + pub(super) fn complete(self) -> Ty { + self.expected_ty + } +} + +pub fn could_coerce( + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + tys: &Canonical<(Ty, Ty)>, +) -> bool { + coerce(db, env, tys).is_ok() +} + +pub(crate) fn coerce( + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + tys: &Canonical<(Ty, Ty)>, +) -> Result<(Vec<Adjustment>, Ty), TypeError> { + let mut table = InferenceTable::new(db, env); + let vars = table.fresh_subst(tys.binders.as_slice(Interner)); + let ty1_with_vars = vars.apply(tys.value.0.clone(), Interner); + let ty2_with_vars = vars.apply(tys.value.1.clone(), Interner); + let (adjustments, ty) = table.coerce(&ty1_with_vars, &ty2_with_vars)?; + // default any type vars that weren't unified back to their original bound vars + // (kind of hacky) + let find_var = |iv| { + vars.iter(Interner).position(|v| match v.interned() { + chalk_ir::GenericArgData::Ty(ty) => ty.inference_var(Interner), + chalk_ir::GenericArgData::Lifetime(lt) => lt.inference_var(Interner), + chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner), + } == Some(iv)) + }; + let fallback = |iv, kind, default, binder| match kind { + chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv) + .map_or(default, |i| BoundVar::new(binder, i).to_ty(Interner).cast(Interner)), + chalk_ir::VariableKind::Lifetime => find_var(iv) + .map_or(default, |i| BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner)), + chalk_ir::VariableKind::Const(ty) => find_var(iv) + .map_or(default, |i| BoundVar::new(binder, i).to_const(Interner, ty).cast(Interner)), + }; + // FIXME also map the types in the adjustments + Ok((adjustments, table.resolve_with_fallback(ty, &fallback))) +} + +impl<'a> InferenceContext<'a> { + /// Unify two types, but may coerce the first one to the second one + /// using "implicit coercion rules" if needed. + pub(super) fn coerce( + &mut self, + expr: Option<ExprId>, + from_ty: &Ty, + to_ty: &Ty, + ) -> Result<Ty, TypeError> { + let from_ty = self.resolve_ty_shallow(from_ty); + let to_ty = self.resolve_ty_shallow(to_ty); + let (adjustments, ty) = self.table.coerce(&from_ty, &to_ty)?; + if let Some(expr) = expr { + self.write_expr_adj(expr, adjustments); + } + Ok(ty) + } +} + +impl<'a> InferenceTable<'a> { + /// Unify two types, but may coerce the first one to the second one + /// using "implicit coercion rules" if needed. + pub(crate) fn coerce( + &mut self, + from_ty: &Ty, + to_ty: &Ty, + ) -> Result<(Vec<Adjustment>, Ty), TypeError> { + let from_ty = self.resolve_ty_shallow(from_ty); + let to_ty = self.resolve_ty_shallow(to_ty); + match self.coerce_inner(from_ty, &to_ty) { + Ok(InferOk { value: (adjustments, ty), goals }) => { + self.register_infer_ok(InferOk { value: (), goals }); + Ok((adjustments, ty)) + } + Err(e) => { + // FIXME deal with error + Err(e) + } + } + } + + fn coerce_inner(&mut self, from_ty: Ty, to_ty: &Ty) -> CoerceResult { + if from_ty.is_never() { + // Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound + // type variable, we want `?T` to fallback to `!` if not + // otherwise constrained. An example where this arises: + // + // let _: Option<?T> = Some({ return; }); + // + // here, we would coerce from `!` to `?T`. + if let TyKind::InferenceVar(tv, TyVariableKind::General) = to_ty.kind(Interner) { + self.set_diverging(*tv, true); + } + return success(simple(Adjust::NeverToAny)(to_ty.clone()), to_ty.clone(), vec![]); + } + + // Consider coercing the subtype to a DST + if let Ok(ret) = self.try_coerce_unsized(&from_ty, to_ty) { + return Ok(ret); + } + + // Examine the supertype and consider auto-borrowing. + match to_ty.kind(Interner) { + TyKind::Raw(mt, _) => return self.coerce_ptr(from_ty, to_ty, *mt), + TyKind::Ref(mt, _, _) => return self.coerce_ref(from_ty, to_ty, *mt), + _ => {} + } + + match from_ty.kind(Interner) { + TyKind::FnDef(..) => { + // Function items are coercible to any closure + // type; function pointers are not (that would + // require double indirection). + // Additionally, we permit coercion of function + // items to drop the unsafe qualifier. + self.coerce_from_fn_item(from_ty, to_ty) + } + TyKind::Function(from_fn_ptr) => { + // We permit coercion of fn pointers to drop the + // unsafe qualifier. + self.coerce_from_fn_pointer(from_ty.clone(), from_fn_ptr, to_ty) + } + TyKind::Closure(_, from_substs) => { + // Non-capturing closures are coercible to + // function pointers or unsafe function pointers. + // It cannot convert closures that require unsafe. + self.coerce_closure_to_fn(from_ty.clone(), from_substs, to_ty) + } + _ => { + // Otherwise, just use unification rules. + self.unify_and(&from_ty, to_ty, identity) + } + } + } + + /// Unify two types (using sub or lub) and produce a specific coercion. + fn unify_and<F>(&mut self, t1: &Ty, t2: &Ty, f: F) -> CoerceResult + where + F: FnOnce(Ty) -> Vec<Adjustment>, + { + self.try_unify(t1, t2) + .and_then(|InferOk { goals, .. }| success(f(t1.clone()), t1.clone(), goals)) + } + + fn coerce_ptr(&mut self, from_ty: Ty, to_ty: &Ty, to_mt: Mutability) -> CoerceResult { + let (is_ref, from_mt, from_inner) = match from_ty.kind(Interner) { + TyKind::Ref(mt, _, ty) => (true, mt, ty), + TyKind::Raw(mt, ty) => (false, mt, ty), + _ => return self.unify_and(&from_ty, to_ty, identity), + }; + + coerce_mutabilities(*from_mt, to_mt)?; + + // Check that the types which they point at are compatible. + let from_raw = TyKind::Raw(to_mt, from_inner.clone()).intern(Interner); + + // Although references and unsafe ptrs have the same + // representation, we still register an Adjust::DerefRef so that + // regionck knows that the region for `a` must be valid here. + if is_ref { + self.unify_and(&from_raw, to_ty, |target| { + vec![ + Adjustment { kind: Adjust::Deref(None), target: from_inner.clone() }, + Adjustment { kind: Adjust::Borrow(AutoBorrow::RawPtr(to_mt)), target }, + ] + }) + } else if *from_mt != to_mt { + self.unify_and( + &from_raw, + to_ty, + simple(Adjust::Pointer(PointerCast::MutToConstPointer)), + ) + } else { + self.unify_and(&from_raw, to_ty, identity) + } + } + + /// Reborrows `&mut A` to `&mut B` and `&(mut) A` to `&B`. + /// To match `A` with `B`, autoderef will be performed, + /// calling `deref`/`deref_mut` where necessary. + fn coerce_ref(&mut self, from_ty: Ty, to_ty: &Ty, to_mt: Mutability) -> CoerceResult { + let from_mt = match from_ty.kind(Interner) { + &TyKind::Ref(mt, _, _) => { + coerce_mutabilities(mt, to_mt)?; + mt + } + _ => return self.unify_and(&from_ty, to_ty, identity), + }; + + // NOTE: this code is mostly copied and adapted from rustc, and + // currently more complicated than necessary, carrying errors around + // etc.. This complication will become necessary when we actually track + // details of coercion errors though, so I think it's useful to leave + // the structure like it is. + + let snapshot = self.snapshot(); + + let mut autoderef = Autoderef::new(self, from_ty.clone()); + let mut first_error = None; + let mut found = None; + + while let Some((referent_ty, autoderefs)) = autoderef.next() { + if autoderefs == 0 { + // Don't let this pass, otherwise it would cause + // &T to autoref to &&T. + continue; + } + + // At this point, we have deref'd `a` to `referent_ty`. So + // imagine we are coercing from `&'a mut Vec<T>` to `&'b mut [T]`. + // In the autoderef loop for `&'a mut Vec<T>`, we would get + // three callbacks: + // + // - `&'a mut Vec<T>` -- 0 derefs, just ignore it + // - `Vec<T>` -- 1 deref + // - `[T]` -- 2 deref + // + // At each point after the first callback, we want to + // check to see whether this would match out target type + // (`&'b mut [T]`) if we autoref'd it. We can't just + // compare the referent types, though, because we still + // have to consider the mutability. E.g., in the case + // we've been considering, we have an `&mut` reference, so + // the `T` in `[T]` needs to be unified with equality. + // + // Therefore, we construct reference types reflecting what + // the types will be after we do the final auto-ref and + // compare those. Note that this means we use the target + // mutability [1], since it may be that we are coercing + // from `&mut T` to `&U`. + let lt = static_lifetime(); // FIXME: handle lifetimes correctly, see rustc + let derefd_from_ty = TyKind::Ref(to_mt, lt, referent_ty).intern(Interner); + match autoderef.table.try_unify(&derefd_from_ty, to_ty) { + Ok(result) => { + found = Some(result.map(|()| derefd_from_ty)); + break; + } + Err(err) => { + if first_error.is_none() { + first_error = Some(err); + } + } + } + } + + // Extract type or return an error. We return the first error + // we got, which should be from relating the "base" type + // (e.g., in example above, the failure from relating `Vec<T>` + // to the target type), since that should be the least + // confusing. + let InferOk { value: ty, goals } = match found { + Some(d) => d, + None => { + self.rollback_to(snapshot); + let err = first_error.expect("coerce_borrowed_pointer had no error"); + return Err(err); + } + }; + if ty == from_ty && from_mt == Mutability::Not && autoderef.step_count() == 1 { + // As a special case, if we would produce `&'a *x`, that's + // a total no-op. We end up with the type `&'a T` just as + // we started with. In that case, just skip it + // altogether. This is just an optimization. + // + // Note that for `&mut`, we DO want to reborrow -- + // otherwise, this would be a move, which might be an + // error. For example `foo(self.x)` where `self` and + // `self.x` both have `&mut `type would be a move of + // `self.x`, but we auto-coerce it to `foo(&mut *self.x)`, + // which is a borrow. + always!(to_mt == Mutability::Not); // can only coerce &T -> &U + return success(vec![], ty, goals); + } + + let mut adjustments = auto_deref_adjust_steps(&autoderef); + adjustments + .push(Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(to_mt)), target: ty.clone() }); + + success(adjustments, ty, goals) + } + + /// Attempts to coerce from the type of a Rust function item into a function pointer. + fn coerce_from_fn_item(&mut self, from_ty: Ty, to_ty: &Ty) -> CoerceResult { + match to_ty.kind(Interner) { + TyKind::Function(_) => { + let from_sig = from_ty.callable_sig(self.db).expect("FnDef had no sig"); + + // FIXME check ABI: Intrinsics are not coercible to function pointers + // FIXME Safe `#[target_feature]` functions are not assignable to safe fn pointers (RFC 2396) + + // FIXME rustc normalizes assoc types in the sig here, not sure if necessary + + let from_sig = from_sig.to_fn_ptr(); + let from_fn_pointer = TyKind::Function(from_sig.clone()).intern(Interner); + let ok = self.coerce_from_safe_fn( + from_fn_pointer.clone(), + &from_sig, + to_ty, + |unsafe_ty| { + vec![ + Adjustment { + kind: Adjust::Pointer(PointerCast::ReifyFnPointer), + target: from_fn_pointer, + }, + Adjustment { + kind: Adjust::Pointer(PointerCast::UnsafeFnPointer), + target: unsafe_ty, + }, + ] + }, + simple(Adjust::Pointer(PointerCast::ReifyFnPointer)), + )?; + + Ok(ok) + } + _ => self.unify_and(&from_ty, to_ty, identity), + } + } + + fn coerce_from_fn_pointer( + &mut self, + from_ty: Ty, + from_f: &FnPointer, + to_ty: &Ty, + ) -> CoerceResult { + self.coerce_from_safe_fn( + from_ty, + from_f, + to_ty, + simple(Adjust::Pointer(PointerCast::UnsafeFnPointer)), + identity, + ) + } + + fn coerce_from_safe_fn<F, G>( + &mut self, + from_ty: Ty, + from_fn_ptr: &FnPointer, + to_ty: &Ty, + to_unsafe: F, + normal: G, + ) -> CoerceResult + where + F: FnOnce(Ty) -> Vec<Adjustment>, + G: FnOnce(Ty) -> Vec<Adjustment>, + { + if let TyKind::Function(to_fn_ptr) = to_ty.kind(Interner) { + if let (chalk_ir::Safety::Safe, chalk_ir::Safety::Unsafe) = + (from_fn_ptr.sig.safety, to_fn_ptr.sig.safety) + { + let from_unsafe = + TyKind::Function(safe_to_unsafe_fn_ty(from_fn_ptr.clone())).intern(Interner); + return self.unify_and(&from_unsafe, to_ty, to_unsafe); + } + } + self.unify_and(&from_ty, to_ty, normal) + } + + /// Attempts to coerce from the type of a non-capturing closure into a + /// function pointer. + fn coerce_closure_to_fn( + &mut self, + from_ty: Ty, + from_substs: &Substitution, + to_ty: &Ty, + ) -> CoerceResult { + match to_ty.kind(Interner) { + // if from_substs is non-capturing (FIXME) + TyKind::Function(fn_ty) => { + // We coerce the closure, which has fn type + // `extern "rust-call" fn((arg0,arg1,...)) -> _` + // to + // `fn(arg0,arg1,...) -> _` + // or + // `unsafe fn(arg0,arg1,...) -> _` + let safety = fn_ty.sig.safety; + let pointer_ty = coerce_closure_fn_ty(from_substs, safety); + self.unify_and( + &pointer_ty, + to_ty, + simple(Adjust::Pointer(PointerCast::ClosureFnPointer(safety))), + ) + } + _ => self.unify_and(&from_ty, to_ty, identity), + } + } + + /// Coerce a type using `from_ty: CoerceUnsized<ty_ty>` + /// + /// See: <https://doc.rust-lang.org/nightly/std/marker/trait.CoerceUnsized.html> + fn try_coerce_unsized(&mut self, from_ty: &Ty, to_ty: &Ty) -> CoerceResult { + // These 'if' statements require some explanation. + // The `CoerceUnsized` trait is special - it is only + // possible to write `impl CoerceUnsized<B> for A` where + // A and B have 'matching' fields. This rules out the following + // two types of blanket impls: + // + // `impl<T> CoerceUnsized<T> for SomeType` + // `impl<T> CoerceUnsized<SomeType> for T` + // + // Both of these trigger a special `CoerceUnsized`-related error (E0376) + // + // We can take advantage of this fact to avoid performing unnecessary work. + // If either `source` or `target` is a type variable, then any applicable impl + // would need to be generic over the self-type (`impl<T> CoerceUnsized<SomeType> for T`) + // or generic over the `CoerceUnsized` type parameter (`impl<T> CoerceUnsized<T> for + // SomeType`). + // + // However, these are exactly the kinds of impls which are forbidden by + // the compiler! Therefore, we can be sure that coercion will always fail + // when either the source or target type is a type variable. This allows us + // to skip performing any trait selection, and immediately bail out. + if from_ty.is_ty_var() { + return Err(TypeError); + } + if to_ty.is_ty_var() { + return Err(TypeError); + } + + // Handle reborrows before trying to solve `Source: CoerceUnsized<Target>`. + let reborrow = match (from_ty.kind(Interner), to_ty.kind(Interner)) { + (TyKind::Ref(from_mt, _, from_inner), &TyKind::Ref(to_mt, _, _)) => { + coerce_mutabilities(*from_mt, to_mt)?; + + let lt = static_lifetime(); + Some(( + Adjustment { kind: Adjust::Deref(None), target: from_inner.clone() }, + Adjustment { + kind: Adjust::Borrow(AutoBorrow::Ref(to_mt)), + target: TyKind::Ref(to_mt, lt, from_inner.clone()).intern(Interner), + }, + )) + } + (TyKind::Ref(from_mt, _, from_inner), &TyKind::Raw(to_mt, _)) => { + coerce_mutabilities(*from_mt, to_mt)?; + + Some(( + Adjustment { kind: Adjust::Deref(None), target: from_inner.clone() }, + Adjustment { + kind: Adjust::Borrow(AutoBorrow::RawPtr(to_mt)), + target: TyKind::Raw(to_mt, from_inner.clone()).intern(Interner), + }, + )) + } + _ => None, + }; + let coerce_from = + reborrow.as_ref().map_or_else(|| from_ty.clone(), |(_, adj)| adj.target.clone()); + + let krate = self.trait_env.krate; + let coerce_unsized_trait = + match self.db.lang_item(krate, SmolStr::new_inline("coerce_unsized")) { + Some(LangItemTarget::TraitId(trait_)) => trait_, + _ => return Err(TypeError), + }; + + let coerce_unsized_tref = { + let b = TyBuilder::trait_ref(self.db, coerce_unsized_trait); + if b.remaining() != 2 { + // The CoerceUnsized trait should have two generic params: Self and T. + return Err(TypeError); + } + b.push(coerce_from).push(to_ty.clone()).build() + }; + + let goal: InEnvironment<DomainGoal> = + InEnvironment::new(&self.trait_env.env, coerce_unsized_tref.cast(Interner)); + + let canonicalized = self.canonicalize(goal); + + // FIXME: rustc's coerce_unsized is more specialized -- it only tries to + // solve `CoerceUnsized` and `Unsize` goals at this point and leaves the + // rest for later. Also, there's some logic about sized type variables. + // Need to find out in what cases this is necessary + let solution = self + .db + .trait_solve(krate, canonicalized.value.clone().cast(Interner)) + .ok_or(TypeError)?; + + match solution { + Solution::Unique(v) => { + canonicalized.apply_solution( + self, + Canonical { + binders: v.binders, + // FIXME handle constraints + value: v.value.subst, + }, + ); + } + Solution::Ambig(Guidance::Definite(subst)) => { + // FIXME need to record an obligation here + canonicalized.apply_solution(self, subst) + } + // FIXME actually we maybe should also accept unknown guidance here + _ => return Err(TypeError), + }; + let unsize = + Adjustment { kind: Adjust::Pointer(PointerCast::Unsize), target: to_ty.clone() }; + let adjustments = match reborrow { + None => vec![unsize], + Some((deref, autoref)) => vec![deref, autoref, unsize], + }; + success(adjustments, to_ty.clone(), vec![]) + } +} + +fn coerce_closure_fn_ty(closure_substs: &Substitution, safety: chalk_ir::Safety) -> Ty { + let closure_sig = closure_substs.at(Interner, 0).assert_ty_ref(Interner).clone(); + match closure_sig.kind(Interner) { + TyKind::Function(fn_ty) => TyKind::Function(FnPointer { + num_binders: fn_ty.num_binders, + sig: FnSig { safety, ..fn_ty.sig }, + substitution: fn_ty.substitution.clone(), + }) + .intern(Interner), + _ => TyKind::Error.intern(Interner), + } +} + +fn safe_to_unsafe_fn_ty(fn_ty: FnPointer) -> FnPointer { + FnPointer { + num_binders: fn_ty.num_binders, + sig: FnSig { safety: chalk_ir::Safety::Unsafe, ..fn_ty.sig }, + substitution: fn_ty.substitution, + } +} + +fn coerce_mutabilities(from: Mutability, to: Mutability) -> Result<(), TypeError> { + match (from, to) { + (Mutability::Mut, Mutability::Mut | Mutability::Not) + | (Mutability::Not, Mutability::Not) => Ok(()), + (Mutability::Not, Mutability::Mut) => Err(TypeError), + } +} + +pub(super) fn auto_deref_adjust_steps(autoderef: &Autoderef<'_, '_>) -> Vec<Adjustment> { + let steps = autoderef.steps(); + let targets = + steps.iter().skip(1).map(|(_, ty)| ty.clone()).chain(iter::once(autoderef.final_ty())); + steps + .iter() + .map(|(kind, _source)| match kind { + // We do not know what kind of deref we require at this point yet + AutoderefKind::Overloaded => Some(OverloadedDeref(Mutability::Not)), + AutoderefKind::Builtin => None, + }) + .zip(targets) + .map(|(autoderef, target)| Adjustment { kind: Adjust::Deref(autoderef), target }) + .collect() +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs new file mode 100644 index 000000000..d164e64a8 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs @@ -0,0 +1,1527 @@ +//! Type inference for expressions. + +use std::{ + collections::hash_map::Entry, + iter::{repeat, repeat_with}, + mem, +}; + +use chalk_ir::{ + cast::Cast, fold::Shift, DebruijnIndex, GenericArgData, Mutability, TyVariableKind, +}; +use hir_def::{ + expr::{ArithOp, Array, BinaryOp, CmpOp, Expr, ExprId, Literal, Ordering, Statement, UnaryOp}, + generics::TypeOrConstParamData, + path::{GenericArg, GenericArgs}, + resolver::resolver_for_expr, + ConstParamId, FieldId, FunctionId, ItemContainerId, Lookup, +}; +use hir_expand::name::{name, Name}; +use stdx::always; +use syntax::ast::RangeOp; + +use crate::{ + autoderef::{self, Autoderef}, + consteval, + infer::coerce::CoerceMany, + lower::{ + const_or_path_to_chalk, generic_arg_to_chalk, lower_to_chalk_mutability, ParamLoweringMode, + }, + mapping::{from_chalk, ToChalk}, + method_resolution::{self, VisibleFromModule}, + primitive::{self, UintTy}, + static_lifetime, to_chalk_trait_id, + utils::{generics, Generics}, + AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, Interner, Rawness, Scalar, + Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind, +}; + +use super::{ + coerce::auto_deref_adjust_steps, find_breakable, BindingMode, BreakableContext, Diverges, + Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch, +}; + +impl<'a> InferenceContext<'a> { + pub(crate) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty { + let ty = self.infer_expr_inner(tgt_expr, expected); + if let Some(expected_ty) = expected.only_has_type(&mut self.table) { + let could_unify = self.unify(&ty, &expected_ty); + if !could_unify { + self.result.type_mismatches.insert( + tgt_expr.into(), + TypeMismatch { expected: expected_ty, actual: ty.clone() }, + ); + } + } + ty + } + + /// Infer type of expression with possibly implicit coerce to the expected type. + /// Return the type after possible coercion. + pub(super) fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty { + let ty = self.infer_expr_inner(expr, expected); + if let Some(target) = expected.only_has_type(&mut self.table) { + match self.coerce(Some(expr), &ty, &target) { + Ok(res) => res, + Err(_) => { + self.result.type_mismatches.insert( + expr.into(), + TypeMismatch { expected: target.clone(), actual: ty.clone() }, + ); + target + } + } + } else { + ty + } + } + + fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty { + self.db.unwind_if_cancelled(); + + let ty = match &self.body[tgt_expr] { + Expr::Missing => self.err_ty(), + &Expr::If { condition, then_branch, else_branch } => { + self.infer_expr( + condition, + &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(Interner)), + ); + + let condition_diverges = mem::replace(&mut self.diverges, Diverges::Maybe); + let mut both_arms_diverge = Diverges::Always; + + let result_ty = self.table.new_type_var(); + let then_ty = self.infer_expr_inner(then_branch, expected); + both_arms_diverge &= mem::replace(&mut self.diverges, Diverges::Maybe); + let mut coerce = CoerceMany::new(result_ty); + coerce.coerce(self, Some(then_branch), &then_ty); + let else_ty = match else_branch { + Some(else_branch) => self.infer_expr_inner(else_branch, expected), + None => TyBuilder::unit(), + }; + both_arms_diverge &= self.diverges; + // FIXME: create a synthetic `else {}` so we have something to refer to here instead of None? + coerce.coerce(self, else_branch, &else_ty); + + self.diverges = condition_diverges | both_arms_diverge; + + coerce.complete() + } + &Expr::Let { pat, expr } => { + let input_ty = self.infer_expr(expr, &Expectation::none()); + self.infer_pat(pat, &input_ty, BindingMode::default()); + TyKind::Scalar(Scalar::Bool).intern(Interner) + } + Expr::Block { statements, tail, label, id: _ } => { + let old_resolver = mem::replace( + &mut self.resolver, + resolver_for_expr(self.db.upcast(), self.owner, tgt_expr), + ); + let ty = match label { + Some(_) => { + let break_ty = self.table.new_type_var(); + self.breakables.push(BreakableContext { + may_break: false, + coerce: CoerceMany::new(break_ty.clone()), + label: label.map(|label| self.body[label].name.clone()), + }); + let ty = self.infer_block( + tgt_expr, + statements, + *tail, + &Expectation::has_type(break_ty), + ); + let ctxt = self.breakables.pop().expect("breakable stack broken"); + if ctxt.may_break { + ctxt.coerce.complete() + } else { + ty + } + } + None => self.infer_block(tgt_expr, statements, *tail, expected), + }; + self.resolver = old_resolver; + ty + } + Expr::Unsafe { body } | Expr::Const { body } => self.infer_expr(*body, expected), + Expr::TryBlock { body } => { + let _inner = self.infer_expr(*body, expected); + // FIXME should be std::result::Result<{inner}, _> + self.err_ty() + } + Expr::Async { body } => { + let ret_ty = self.table.new_type_var(); + let prev_diverges = mem::replace(&mut self.diverges, Diverges::Maybe); + let prev_ret_ty = mem::replace(&mut self.return_ty, ret_ty.clone()); + + let inner_ty = self.infer_expr_coerce(*body, &Expectation::has_type(ret_ty)); + + self.diverges = prev_diverges; + self.return_ty = prev_ret_ty; + + // Use the first type parameter as the output type of future. + // existential type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType> + let impl_trait_id = crate::ImplTraitId::AsyncBlockTypeImplTrait(self.owner, *body); + let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); + TyKind::OpaqueType(opaque_ty_id, Substitution::from1(Interner, inner_ty)) + .intern(Interner) + } + Expr::Loop { body, label } => { + self.breakables.push(BreakableContext { + may_break: false, + coerce: CoerceMany::new(self.table.new_type_var()), + label: label.map(|label| self.body[label].name.clone()), + }); + self.infer_expr(*body, &Expectation::has_type(TyBuilder::unit())); + + let ctxt = self.breakables.pop().expect("breakable stack broken"); + + if ctxt.may_break { + self.diverges = Diverges::Maybe; + ctxt.coerce.complete() + } else { + TyKind::Never.intern(Interner) + } + } + Expr::While { condition, body, label } => { + self.breakables.push(BreakableContext { + may_break: false, + coerce: CoerceMany::new(self.err_ty()), + label: label.map(|label| self.body[label].name.clone()), + }); + self.infer_expr( + *condition, + &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(Interner)), + ); + self.infer_expr(*body, &Expectation::has_type(TyBuilder::unit())); + let _ctxt = self.breakables.pop().expect("breakable stack broken"); + // the body may not run, so it diverging doesn't mean we diverge + self.diverges = Diverges::Maybe; + TyBuilder::unit() + } + Expr::For { iterable, body, pat, label } => { + let iterable_ty = self.infer_expr(*iterable, &Expectation::none()); + + self.breakables.push(BreakableContext { + may_break: false, + coerce: CoerceMany::new(self.err_ty()), + label: label.map(|label| self.body[label].name.clone()), + }); + let pat_ty = + self.resolve_associated_type(iterable_ty, self.resolve_into_iter_item()); + + self.infer_pat(*pat, &pat_ty, BindingMode::default()); + + self.infer_expr(*body, &Expectation::has_type(TyBuilder::unit())); + let _ctxt = self.breakables.pop().expect("breakable stack broken"); + // the body may not run, so it diverging doesn't mean we diverge + self.diverges = Diverges::Maybe; + TyBuilder::unit() + } + Expr::Closure { body, args, ret_type, arg_types } => { + assert_eq!(args.len(), arg_types.len()); + + let mut sig_tys = Vec::new(); + + // collect explicitly written argument types + for arg_type in arg_types.iter() { + let arg_ty = match arg_type { + Some(type_ref) => self.make_ty(type_ref), + None => self.table.new_type_var(), + }; + sig_tys.push(arg_ty); + } + + // add return type + let ret_ty = match ret_type { + Some(type_ref) => self.make_ty(type_ref), + None => self.table.new_type_var(), + }; + sig_tys.push(ret_ty.clone()); + let sig_ty = TyKind::Function(FnPointer { + num_binders: 0, + sig: FnSig { abi: (), safety: chalk_ir::Safety::Safe, variadic: false }, + substitution: FnSubst( + Substitution::from_iter(Interner, sig_tys.clone()).shifted_in(Interner), + ), + }) + .intern(Interner); + let closure_id = self.db.intern_closure((self.owner, tgt_expr)).into(); + let closure_ty = + TyKind::Closure(closure_id, Substitution::from1(Interner, sig_ty.clone())) + .intern(Interner); + + // Eagerly try to relate the closure type with the expected + // type, otherwise we often won't have enough information to + // infer the body. + self.deduce_closure_type_from_expectations( + tgt_expr, + &closure_ty, + &sig_ty, + expected, + ); + + // Now go through the argument patterns + for (arg_pat, arg_ty) in args.iter().zip(sig_tys) { + self.infer_pat(*arg_pat, &arg_ty, BindingMode::default()); + } + + let prev_diverges = mem::replace(&mut self.diverges, Diverges::Maybe); + let prev_ret_ty = mem::replace(&mut self.return_ty, ret_ty.clone()); + + self.infer_expr_coerce(*body, &Expectation::has_type(ret_ty)); + + self.diverges = prev_diverges; + self.return_ty = prev_ret_ty; + + closure_ty + } + Expr::Call { callee, args, .. } => { + let callee_ty = self.infer_expr(*callee, &Expectation::none()); + let mut derefs = Autoderef::new(&mut self.table, callee_ty.clone()); + let mut res = None; + let mut derefed_callee = callee_ty.clone(); + // manual loop to be able to access `derefs.table` + while let Some((callee_deref_ty, _)) = derefs.next() { + res = derefs.table.callable_sig(&callee_deref_ty, args.len()); + if res.is_some() { + derefed_callee = callee_deref_ty; + break; + } + } + // if the function is unresolved, we use is_varargs=true to + // suppress the arg count diagnostic here + let is_varargs = + derefed_callee.callable_sig(self.db).map_or(false, |sig| sig.is_varargs) + || res.is_none(); + let (param_tys, ret_ty) = match res { + Some(res) => { + let adjustments = auto_deref_adjust_steps(&derefs); + self.write_expr_adj(*callee, adjustments); + res + } + None => (Vec::new(), self.err_ty()), // FIXME diagnostic + }; + let indices_to_skip = self.check_legacy_const_generics(derefed_callee, args); + self.register_obligations_for_call(&callee_ty); + + let expected_inputs = self.expected_inputs_for_expected_output( + expected, + ret_ty.clone(), + param_tys.clone(), + ); + + self.check_call_arguments( + tgt_expr, + args, + &expected_inputs, + ¶m_tys, + &indices_to_skip, + is_varargs, + ); + self.normalize_associated_types_in(ret_ty) + } + Expr::MethodCall { receiver, args, method_name, generic_args } => self + .infer_method_call( + tgt_expr, + *receiver, + args, + method_name, + generic_args.as_deref(), + expected, + ), + Expr::Match { expr, arms } => { + let input_ty = self.infer_expr(*expr, &Expectation::none()); + + let expected = expected.adjust_for_branches(&mut self.table); + + let result_ty = if arms.is_empty() { + TyKind::Never.intern(Interner) + } else { + match &expected { + Expectation::HasType(ty) => ty.clone(), + _ => self.table.new_type_var(), + } + }; + let mut coerce = CoerceMany::new(result_ty); + + let matchee_diverges = self.diverges; + let mut all_arms_diverge = Diverges::Always; + + for arm in arms.iter() { + self.diverges = Diverges::Maybe; + let _pat_ty = self.infer_pat(arm.pat, &input_ty, BindingMode::default()); + if let Some(guard_expr) = arm.guard { + self.infer_expr( + guard_expr, + &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(Interner)), + ); + } + + let arm_ty = self.infer_expr_inner(arm.expr, &expected); + all_arms_diverge &= self.diverges; + coerce.coerce(self, Some(arm.expr), &arm_ty); + } + + self.diverges = matchee_diverges | all_arms_diverge; + + coerce.complete() + } + Expr::Path(p) => { + // FIXME this could be more efficient... + let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr); + self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or_else(|| self.err_ty()) + } + Expr::Continue { .. } => TyKind::Never.intern(Interner), + Expr::Break { expr, label } => { + let mut coerce = match find_breakable(&mut self.breakables, label.as_ref()) { + Some(ctxt) => { + // avoiding the borrowck + mem::replace( + &mut ctxt.coerce, + CoerceMany::new(self.result.standard_types.unknown.clone()), + ) + } + None => CoerceMany::new(self.result.standard_types.unknown.clone()), + }; + + let val_ty = if let Some(expr) = *expr { + self.infer_expr(expr, &Expectation::none()) + } else { + TyBuilder::unit() + }; + + // FIXME: create a synthetic `()` during lowering so we have something to refer to here? + coerce.coerce(self, *expr, &val_ty); + + if let Some(ctxt) = find_breakable(&mut self.breakables, label.as_ref()) { + ctxt.coerce = coerce; + ctxt.may_break = true; + } else { + self.push_diagnostic(InferenceDiagnostic::BreakOutsideOfLoop { + expr: tgt_expr, + }); + }; + + TyKind::Never.intern(Interner) + } + Expr::Return { expr } => { + if let Some(expr) = expr { + self.infer_expr_coerce(*expr, &Expectation::has_type(self.return_ty.clone())); + } else { + let unit = TyBuilder::unit(); + let _ = self.coerce(Some(tgt_expr), &unit, &self.return_ty.clone()); + } + TyKind::Never.intern(Interner) + } + Expr::Yield { expr } => { + // FIXME: track yield type for coercion + if let Some(expr) = expr { + self.infer_expr(*expr, &Expectation::none()); + } + TyKind::Never.intern(Interner) + } + Expr::RecordLit { path, fields, spread, .. } => { + let (ty, def_id) = self.resolve_variant(path.as_deref(), false); + if let Some(variant) = def_id { + self.write_variant_resolution(tgt_expr.into(), variant); + } + + if let Some(t) = expected.only_has_type(&mut self.table) { + self.unify(&ty, &t); + } + + let substs = ty + .as_adt() + .map(|(_, s)| s.clone()) + .unwrap_or_else(|| Substitution::empty(Interner)); + let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default(); + let variant_data = def_id.map(|it| it.variant_data(self.db.upcast())); + for field in fields.iter() { + let field_def = + variant_data.as_ref().and_then(|it| match it.field(&field.name) { + Some(local_id) => Some(FieldId { parent: def_id.unwrap(), local_id }), + None => { + self.push_diagnostic(InferenceDiagnostic::NoSuchField { + expr: field.expr, + }); + None + } + }); + let field_ty = field_def.map_or(self.err_ty(), |it| { + field_types[it.local_id].clone().substitute(Interner, &substs) + }); + self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty)); + } + if let Some(expr) = spread { + self.infer_expr(*expr, &Expectation::has_type(ty.clone())); + } + ty + } + Expr::Field { expr, name } => { + let receiver_ty = self.infer_expr_inner(*expr, &Expectation::none()); + + let mut autoderef = Autoderef::new(&mut self.table, receiver_ty); + let ty = autoderef.by_ref().find_map(|(derefed_ty, _)| { + let (field_id, parameters) = match derefed_ty.kind(Interner) { + TyKind::Tuple(_, substs) => { + return name.as_tuple_index().and_then(|idx| { + substs + .as_slice(Interner) + .get(idx) + .map(|a| a.assert_ty_ref(Interner)) + .cloned() + }); + } + TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => { + let local_id = self.db.struct_data(*s).variant_data.field(name)?; + let field = FieldId { parent: (*s).into(), local_id }; + (field, parameters.clone()) + } + TyKind::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => { + let local_id = self.db.union_data(*u).variant_data.field(name)?; + let field = FieldId { parent: (*u).into(), local_id }; + (field, parameters.clone()) + } + _ => return None, + }; + let is_visible = self.db.field_visibilities(field_id.parent)[field_id.local_id] + .is_visible_from(self.db.upcast(), self.resolver.module()); + if !is_visible { + // Write down the first field resolution even if it is not visible + // This aids IDE features for private fields like goto def and in + // case of autoderef finding an applicable field, this will be + // overwritten in a following cycle + if let Entry::Vacant(entry) = self.result.field_resolutions.entry(tgt_expr) + { + entry.insert(field_id); + } + return None; + } + // can't have `write_field_resolution` here because `self.table` is borrowed :( + self.result.field_resolutions.insert(tgt_expr, field_id); + let ty = self.db.field_types(field_id.parent)[field_id.local_id] + .clone() + .substitute(Interner, ¶meters); + Some(ty) + }); + let ty = match ty { + Some(ty) => { + let adjustments = auto_deref_adjust_steps(&autoderef); + self.write_expr_adj(*expr, adjustments); + let ty = self.insert_type_vars(ty); + let ty = self.normalize_associated_types_in(ty); + ty + } + _ => self.err_ty(), + }; + ty + } + Expr::Await { expr } => { + let inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); + self.resolve_associated_type(inner_ty, self.resolve_future_future_output()) + } + Expr::Try { expr } => { + let inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); + self.resolve_associated_type(inner_ty, self.resolve_ops_try_ok()) + } + Expr::Cast { expr, type_ref } => { + // FIXME: propagate the "castable to" expectation (and find a test case that shows this is necessary) + let _inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); + let cast_ty = self.make_ty(type_ref); + // FIXME check the cast... + cast_ty + } + Expr::Ref { expr, rawness, mutability } => { + let mutability = lower_to_chalk_mutability(*mutability); + let expectation = if let Some((exp_inner, exp_rawness, exp_mutability)) = expected + .only_has_type(&mut self.table) + .as_ref() + .and_then(|t| t.as_reference_or_ptr()) + { + if exp_mutability == Mutability::Mut && mutability == Mutability::Not { + // FIXME: record type error - expected mut reference but found shared ref, + // which cannot be coerced + } + if exp_rawness == Rawness::Ref && *rawness == Rawness::RawPtr { + // FIXME: record type error - expected reference but found ptr, + // which cannot be coerced + } + Expectation::rvalue_hint(&mut self.table, Ty::clone(exp_inner)) + } else { + Expectation::none() + }; + let inner_ty = self.infer_expr_inner(*expr, &expectation); + match rawness { + Rawness::RawPtr => TyKind::Raw(mutability, inner_ty), + Rawness::Ref => TyKind::Ref(mutability, static_lifetime(), inner_ty), + } + .intern(Interner) + } + &Expr::Box { expr } => self.infer_expr_box(expr, expected), + Expr::UnaryOp { expr, op } => { + let inner_ty = self.infer_expr_inner(*expr, &Expectation::none()); + let inner_ty = self.resolve_ty_shallow(&inner_ty); + match op { + UnaryOp::Deref => { + autoderef::deref(&mut self.table, inner_ty).unwrap_or_else(|| self.err_ty()) + } + UnaryOp::Neg => { + match inner_ty.kind(Interner) { + // Fast path for builtins + TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_)) + | TyKind::InferenceVar( + _, + TyVariableKind::Integer | TyVariableKind::Float, + ) => inner_ty, + // Otherwise we resolve via the std::ops::Neg trait + _ => self + .resolve_associated_type(inner_ty, self.resolve_ops_neg_output()), + } + } + UnaryOp::Not => { + match inner_ty.kind(Interner) { + // Fast path for builtins + TyKind::Scalar(Scalar::Bool | Scalar::Int(_) | Scalar::Uint(_)) + | TyKind::InferenceVar(_, TyVariableKind::Integer) => inner_ty, + // Otherwise we resolve via the std::ops::Not trait + _ => self + .resolve_associated_type(inner_ty, self.resolve_ops_not_output()), + } + } + } + } + Expr::BinaryOp { lhs, rhs, op } => match op { + Some(BinaryOp::Assignment { op: None }) => { + let lhs = *lhs; + let is_ordinary = match &self.body[lhs] { + Expr::Array(_) + | Expr::RecordLit { .. } + | Expr::Tuple { .. } + | Expr::Underscore => false, + Expr::Call { callee, .. } => !matches!(&self.body[*callee], Expr::Path(_)), + _ => true, + }; + + // In ordinary (non-destructuring) assignments, the type of + // `lhs` must be inferred first so that the ADT fields + // instantiations in RHS can be coerced to it. Note that this + // cannot happen in destructuring assignments because of how + // they are desugared. + if is_ordinary { + let lhs_ty = self.infer_expr(lhs, &Expectation::none()); + self.infer_expr_coerce(*rhs, &Expectation::has_type(lhs_ty)); + } else { + let rhs_ty = self.infer_expr(*rhs, &Expectation::none()); + self.infer_assignee_expr(lhs, &rhs_ty); + } + self.result.standard_types.unit.clone() + } + Some(BinaryOp::LogicOp(_)) => { + let bool_ty = self.result.standard_types.bool_.clone(); + self.infer_expr_coerce(*lhs, &Expectation::HasType(bool_ty.clone())); + let lhs_diverges = self.diverges; + self.infer_expr_coerce(*rhs, &Expectation::HasType(bool_ty.clone())); + // Depending on the LHS' value, the RHS can never execute. + self.diverges = lhs_diverges; + bool_ty + } + Some(op) => self.infer_overloadable_binop(*lhs, *op, *rhs, tgt_expr), + _ => self.err_ty(), + }, + Expr::Range { lhs, rhs, range_type } => { + let lhs_ty = lhs.map(|e| self.infer_expr_inner(e, &Expectation::none())); + let rhs_expect = lhs_ty + .as_ref() + .map_or_else(Expectation::none, |ty| Expectation::has_type(ty.clone())); + let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect)); + match (range_type, lhs_ty, rhs_ty) { + (RangeOp::Exclusive, None, None) => match self.resolve_range_full() { + Some(adt) => TyBuilder::adt(self.db, adt).build(), + None => self.err_ty(), + }, + (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() { + Some(adt) => TyBuilder::adt(self.db, adt).push(ty).build(), + None => self.err_ty(), + }, + (RangeOp::Inclusive, None, Some(ty)) => { + match self.resolve_range_to_inclusive() { + Some(adt) => TyBuilder::adt(self.db, adt).push(ty).build(), + None => self.err_ty(), + } + } + (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() { + Some(adt) => TyBuilder::adt(self.db, adt).push(ty).build(), + None => self.err_ty(), + }, + (RangeOp::Inclusive, Some(_), Some(ty)) => { + match self.resolve_range_inclusive() { + Some(adt) => TyBuilder::adt(self.db, adt).push(ty).build(), + None => self.err_ty(), + } + } + (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() { + Some(adt) => TyBuilder::adt(self.db, adt).push(ty).build(), + None => self.err_ty(), + }, + (RangeOp::Inclusive, _, None) => self.err_ty(), + } + } + Expr::Index { base, index } => { + let base_ty = self.infer_expr_inner(*base, &Expectation::none()); + let index_ty = self.infer_expr(*index, &Expectation::none()); + + if let Some(index_trait) = self.resolve_ops_index() { + let canonicalized = self.canonicalize(base_ty.clone()); + let receiver_adjustments = method_resolution::resolve_indexing_op( + self.db, + self.trait_env.clone(), + canonicalized.value, + index_trait, + ); + let (self_ty, adj) = receiver_adjustments + .map_or((self.err_ty(), Vec::new()), |adj| { + adj.apply(&mut self.table, base_ty) + }); + self.write_expr_adj(*base, adj); + self.resolve_associated_type_with_params( + self_ty, + self.resolve_ops_index_output(), + &[GenericArgData::Ty(index_ty).intern(Interner)], + ) + } else { + self.err_ty() + } + } + Expr::Tuple { exprs, .. } => { + let mut tys = match expected + .only_has_type(&mut self.table) + .as_ref() + .map(|t| t.kind(Interner)) + { + Some(TyKind::Tuple(_, substs)) => substs + .iter(Interner) + .map(|a| a.assert_ty_ref(Interner).clone()) + .chain(repeat_with(|| self.table.new_type_var())) + .take(exprs.len()) + .collect::<Vec<_>>(), + _ => (0..exprs.len()).map(|_| self.table.new_type_var()).collect(), + }; + + for (expr, ty) in exprs.iter().zip(tys.iter_mut()) { + self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone())); + } + + TyKind::Tuple(tys.len(), Substitution::from_iter(Interner, tys)).intern(Interner) + } + Expr::Array(array) => { + let elem_ty = + match expected.to_option(&mut self.table).as_ref().map(|t| t.kind(Interner)) { + Some(TyKind::Array(st, _) | TyKind::Slice(st)) => st.clone(), + _ => self.table.new_type_var(), + }; + let mut coerce = CoerceMany::new(elem_ty.clone()); + + let expected = Expectation::has_type(elem_ty.clone()); + let len = match array { + Array::ElementList { elements, .. } => { + for &expr in elements.iter() { + let cur_elem_ty = self.infer_expr_inner(expr, &expected); + coerce.coerce(self, Some(expr), &cur_elem_ty); + } + consteval::usize_const(Some(elements.len() as u128)) + } + &Array::Repeat { initializer, repeat } => { + self.infer_expr_coerce(initializer, &Expectation::has_type(elem_ty)); + self.infer_expr( + repeat, + &Expectation::has_type( + TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(Interner), + ), + ); + + if let Some(g_def) = self.owner.as_generic_def_id() { + let generics = generics(self.db.upcast(), g_def); + consteval::eval_to_const( + repeat, + ParamLoweringMode::Placeholder, + self, + || generics, + DebruijnIndex::INNERMOST, + ) + } else { + consteval::usize_const(None) + } + } + }; + + TyKind::Array(coerce.complete(), len).intern(Interner) + } + Expr::Literal(lit) => match lit { + Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(Interner), + Literal::String(..) => { + TyKind::Ref(Mutability::Not, static_lifetime(), TyKind::Str.intern(Interner)) + .intern(Interner) + } + Literal::ByteString(bs) => { + let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(Interner); + + let len = consteval::usize_const(Some(bs.len() as u128)); + + let array_type = TyKind::Array(byte_type, len).intern(Interner); + TyKind::Ref(Mutability::Not, static_lifetime(), array_type).intern(Interner) + } + Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(Interner), + Literal::Int(_v, ty) => match ty { + Some(int_ty) => { + TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty))) + .intern(Interner) + } + None => self.table.new_integer_var(), + }, + Literal::Uint(_v, ty) => match ty { + Some(int_ty) => { + TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty))) + .intern(Interner) + } + None => self.table.new_integer_var(), + }, + Literal::Float(_v, ty) => match ty { + Some(float_ty) => { + TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty))) + .intern(Interner) + } + None => self.table.new_float_var(), + }, + }, + Expr::MacroStmts { tail, statements } => { + self.infer_block(tgt_expr, statements, *tail, expected) + } + Expr::Underscore => { + // Underscore expressions may only appear in assignee expressions, + // which are handled by `infer_assignee_expr()`, so any underscore + // expression reaching this branch is an error. + self.err_ty() + } + }; + // use a new type variable if we got unknown here + let ty = self.insert_type_vars_shallow(ty); + self.write_expr_ty(tgt_expr, ty.clone()); + if self.resolve_ty_shallow(&ty).is_never() { + // Any expression that produces a value of type `!` must have diverged + self.diverges = Diverges::Always; + } + ty + } + + fn infer_expr_box(&mut self, inner_expr: ExprId, expected: &Expectation) -> Ty { + if let Some(box_id) = self.resolve_boxed_box() { + let table = &mut self.table; + let inner_exp = expected + .to_option(table) + .as_ref() + .map(|e| e.as_adt()) + .flatten() + .filter(|(e_adt, _)| e_adt == &box_id) + .map(|(_, subts)| { + let g = subts.at(Interner, 0); + Expectation::rvalue_hint(table, Ty::clone(g.assert_ty_ref(Interner))) + }) + .unwrap_or_else(Expectation::none); + + let inner_ty = self.infer_expr_inner(inner_expr, &inner_exp); + TyBuilder::adt(self.db, box_id) + .push(inner_ty) + .fill_with_defaults(self.db, || self.table.new_type_var()) + .build() + } else { + self.err_ty() + } + } + + pub(super) fn infer_assignee_expr(&mut self, lhs: ExprId, rhs_ty: &Ty) -> Ty { + let is_rest_expr = |expr| { + matches!( + &self.body[expr], + Expr::Range { lhs: None, rhs: None, range_type: RangeOp::Exclusive }, + ) + }; + + let rhs_ty = self.resolve_ty_shallow(rhs_ty); + + let ty = match &self.body[lhs] { + Expr::Tuple { exprs, .. } => { + // We don't consider multiple ellipses. This is analogous to + // `hir_def::body::lower::ExprCollector::collect_tuple_pat()`. + let ellipsis = exprs.iter().position(|e| is_rest_expr(*e)); + let exprs: Vec<_> = exprs.iter().filter(|e| !is_rest_expr(**e)).copied().collect(); + + self.infer_tuple_pat_like(&rhs_ty, (), ellipsis, &exprs) + } + Expr::Call { callee, args, .. } => { + // Tuple structs + let path = match &self.body[*callee] { + Expr::Path(path) => Some(path), + _ => None, + }; + + // We don't consider multiple ellipses. This is analogous to + // `hir_def::body::lower::ExprCollector::collect_tuple_pat()`. + let ellipsis = args.iter().position(|e| is_rest_expr(*e)); + let args: Vec<_> = args.iter().filter(|e| !is_rest_expr(**e)).copied().collect(); + + self.infer_tuple_struct_pat_like(path, &rhs_ty, (), lhs, ellipsis, &args) + } + Expr::Array(Array::ElementList { elements, .. }) => { + let elem_ty = match rhs_ty.kind(Interner) { + TyKind::Array(st, _) => st.clone(), + _ => self.err_ty(), + }; + + // There's no need to handle `..` as it cannot be bound. + let sub_exprs = elements.iter().filter(|e| !is_rest_expr(**e)); + + for e in sub_exprs { + self.infer_assignee_expr(*e, &elem_ty); + } + + match rhs_ty.kind(Interner) { + TyKind::Array(_, _) => rhs_ty.clone(), + // Even when `rhs_ty` is not an array type, this assignee + // expression is inferred to be an array (of unknown element + // type and length). This should not be just an error type, + // because we are to compute the unifiability of this type and + // `rhs_ty` in the end of this function to issue type mismatches. + _ => TyKind::Array(self.err_ty(), crate::consteval::usize_const(None)) + .intern(Interner), + } + } + Expr::RecordLit { path, fields, .. } => { + let subs = fields.iter().map(|f| (f.name.clone(), f.expr)); + + self.infer_record_pat_like(path.as_deref(), &rhs_ty, (), lhs.into(), subs) + } + Expr::Underscore => rhs_ty.clone(), + _ => { + // `lhs` is a place expression, a unit struct, or an enum variant. + let lhs_ty = self.infer_expr(lhs, &Expectation::none()); + + // This is the only branch where this function may coerce any type. + // We are returning early to avoid the unifiability check below. + let lhs_ty = self.insert_type_vars_shallow(lhs_ty); + let ty = match self.coerce(None, &rhs_ty, &lhs_ty) { + Ok(ty) => ty, + Err(_) => { + self.result.type_mismatches.insert( + lhs.into(), + TypeMismatch { expected: rhs_ty.clone(), actual: lhs_ty.clone() }, + ); + // `rhs_ty` is returned so no further type mismatches are + // reported because of this mismatch. + rhs_ty + } + }; + self.write_expr_ty(lhs, ty.clone()); + return ty; + } + }; + + let ty = self.insert_type_vars_shallow(ty); + if !self.unify(&ty, &rhs_ty) { + self.result + .type_mismatches + .insert(lhs.into(), TypeMismatch { expected: rhs_ty.clone(), actual: ty.clone() }); + } + self.write_expr_ty(lhs, ty.clone()); + ty + } + + fn infer_overloadable_binop( + &mut self, + lhs: ExprId, + op: BinaryOp, + rhs: ExprId, + tgt_expr: ExprId, + ) -> Ty { + let lhs_expectation = Expectation::none(); + let lhs_ty = self.infer_expr(lhs, &lhs_expectation); + let rhs_ty = self.table.new_type_var(); + + let func = self.resolve_binop_method(op); + let func = match func { + Some(func) => func, + None => { + let rhs_ty = self.builtin_binary_op_rhs_expectation(op, lhs_ty.clone()); + let rhs_ty = self.infer_expr_coerce(rhs, &Expectation::from_option(rhs_ty)); + return self + .builtin_binary_op_return_ty(op, lhs_ty, rhs_ty) + .unwrap_or_else(|| self.err_ty()); + } + }; + + let subst = TyBuilder::subst_for_def(self.db, func) + .push(lhs_ty.clone()) + .push(rhs_ty.clone()) + .build(); + self.write_method_resolution(tgt_expr, func, subst.clone()); + + let method_ty = self.db.value_ty(func.into()).substitute(Interner, &subst); + self.register_obligations_for_call(&method_ty); + + self.infer_expr_coerce(rhs, &Expectation::has_type(rhs_ty.clone())); + + let ret_ty = match method_ty.callable_sig(self.db) { + Some(sig) => sig.ret().clone(), + None => self.err_ty(), + }; + + let ret_ty = self.normalize_associated_types_in(ret_ty); + + // FIXME: record autoref adjustments + + // use knowledge of built-in binary ops, which can sometimes help inference + if let Some(builtin_rhs) = self.builtin_binary_op_rhs_expectation(op, lhs_ty.clone()) { + self.unify(&builtin_rhs, &rhs_ty); + } + if let Some(builtin_ret) = self.builtin_binary_op_return_ty(op, lhs_ty, rhs_ty) { + self.unify(&builtin_ret, &ret_ty); + } + + ret_ty + } + + fn infer_block( + &mut self, + expr: ExprId, + statements: &[Statement], + tail: Option<ExprId>, + expected: &Expectation, + ) -> Ty { + for stmt in statements { + match stmt { + Statement::Let { pat, type_ref, initializer, else_branch } => { + let decl_ty = type_ref + .as_ref() + .map(|tr| self.make_ty(tr)) + .unwrap_or_else(|| self.err_ty()); + + // Always use the declared type when specified + let mut ty = decl_ty.clone(); + + if let Some(expr) = initializer { + let actual_ty = + self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone())); + if decl_ty.is_unknown() { + ty = actual_ty; + } + } + + if let Some(expr) = else_branch { + self.infer_expr_coerce( + *expr, + &Expectation::has_type(Ty::new(Interner, TyKind::Never)), + ); + } + + self.infer_pat(*pat, &ty, BindingMode::default()); + } + Statement::Expr { expr, .. } => { + self.infer_expr(*expr, &Expectation::none()); + } + } + } + + if let Some(expr) = tail { + self.infer_expr_coerce(expr, expected) + } else { + // Citing rustc: if there is no explicit tail expression, + // that is typically equivalent to a tail expression + // of `()` -- except if the block diverges. In that + // case, there is no value supplied from the tail + // expression (assuming there are no other breaks, + // this implies that the type of the block will be + // `!`). + if self.diverges.is_always() { + // we don't even make an attempt at coercion + self.table.new_maybe_never_var() + } else { + if let Some(t) = expected.only_has_type(&mut self.table) { + if self.coerce(Some(expr), &TyBuilder::unit(), &t).is_err() { + self.result.type_mismatches.insert( + expr.into(), + TypeMismatch { expected: t.clone(), actual: TyBuilder::unit() }, + ); + } + t + } else { + TyBuilder::unit() + } + } + } + } + + fn infer_method_call( + &mut self, + tgt_expr: ExprId, + receiver: ExprId, + args: &[ExprId], + method_name: &Name, + generic_args: Option<&GenericArgs>, + expected: &Expectation, + ) -> Ty { + let receiver_ty = self.infer_expr(receiver, &Expectation::none()); + let canonicalized_receiver = self.canonicalize(receiver_ty.clone()); + + let traits_in_scope = self.resolver.traits_in_scope(self.db.upcast()); + + let resolved = method_resolution::lookup_method( + &canonicalized_receiver.value, + self.db, + self.trait_env.clone(), + &traits_in_scope, + VisibleFromModule::Filter(self.resolver.module()), + method_name, + ); + let (receiver_ty, method_ty, substs) = match resolved { + Some((adjust, func)) => { + let (ty, adjustments) = adjust.apply(&mut self.table, receiver_ty); + let generics = generics(self.db.upcast(), func.into()); + let substs = self.substs_for_method_call(generics, generic_args); + self.write_expr_adj(receiver, adjustments); + self.write_method_resolution(tgt_expr, func, substs.clone()); + (ty, self.db.value_ty(func.into()), substs) + } + None => ( + receiver_ty, + Binders::empty(Interner, self.err_ty()), + Substitution::empty(Interner), + ), + }; + let method_ty = method_ty.substitute(Interner, &substs); + self.register_obligations_for_call(&method_ty); + let (formal_receiver_ty, param_tys, ret_ty, is_varargs) = + match method_ty.callable_sig(self.db) { + Some(sig) => { + if !sig.params().is_empty() { + ( + sig.params()[0].clone(), + sig.params()[1..].to_vec(), + sig.ret().clone(), + sig.is_varargs, + ) + } else { + (self.err_ty(), Vec::new(), sig.ret().clone(), sig.is_varargs) + } + } + None => (self.err_ty(), Vec::new(), self.err_ty(), true), + }; + self.unify(&formal_receiver_ty, &receiver_ty); + + let expected_inputs = + self.expected_inputs_for_expected_output(expected, ret_ty.clone(), param_tys.clone()); + + self.check_call_arguments(tgt_expr, args, &expected_inputs, ¶m_tys, &[], is_varargs); + self.normalize_associated_types_in(ret_ty) + } + + fn expected_inputs_for_expected_output( + &mut self, + expected_output: &Expectation, + output: Ty, + inputs: Vec<Ty>, + ) -> Vec<Ty> { + if let Some(expected_ty) = expected_output.to_option(&mut self.table) { + self.table.fudge_inference(|table| { + if table.try_unify(&expected_ty, &output).is_ok() { + table.resolve_with_fallback(inputs, &|var, kind, _, _| match kind { + chalk_ir::VariableKind::Ty(tk) => var.to_ty(Interner, tk).cast(Interner), + chalk_ir::VariableKind::Lifetime => { + var.to_lifetime(Interner).cast(Interner) + } + chalk_ir::VariableKind::Const(ty) => { + var.to_const(Interner, ty).cast(Interner) + } + }) + } else { + Vec::new() + } + }) + } else { + Vec::new() + } + } + + fn check_call_arguments( + &mut self, + expr: ExprId, + args: &[ExprId], + expected_inputs: &[Ty], + param_tys: &[Ty], + skip_indices: &[u32], + is_varargs: bool, + ) { + if args.len() != param_tys.len() + skip_indices.len() && !is_varargs { + self.push_diagnostic(InferenceDiagnostic::MismatchedArgCount { + call_expr: expr, + expected: param_tys.len() + skip_indices.len(), + found: args.len(), + }); + } + + // Quoting https://github.com/rust-lang/rust/blob/6ef275e6c3cb1384ec78128eceeb4963ff788dca/src/librustc_typeck/check/mod.rs#L3325 -- + // We do this in a pretty awful way: first we type-check any arguments + // that are not closures, then we type-check the closures. This is so + // that we have more information about the types of arguments when we + // type-check the functions. This isn't really the right way to do this. + for &check_closures in &[false, true] { + let mut skip_indices = skip_indices.into_iter().copied().fuse().peekable(); + let param_iter = param_tys.iter().cloned().chain(repeat(self.err_ty())); + let expected_iter = expected_inputs + .iter() + .cloned() + .chain(param_iter.clone().skip(expected_inputs.len())); + for (idx, ((&arg, param_ty), expected_ty)) in + args.iter().zip(param_iter).zip(expected_iter).enumerate() + { + let is_closure = matches!(&self.body[arg], Expr::Closure { .. }); + if is_closure != check_closures { + continue; + } + + while skip_indices.peek().map_or(false, |i| *i < idx as u32) { + skip_indices.next(); + } + if skip_indices.peek().copied() == Some(idx as u32) { + continue; + } + + // the difference between param_ty and expected here is that + // expected is the parameter when the expected *return* type is + // taken into account. So in `let _: &[i32] = identity(&[1, 2])` + // the expected type is already `&[i32]`, whereas param_ty is + // still an unbound type variable. We don't always want to force + // the parameter to coerce to the expected type (for example in + // `coerce_unsize_expected_type_4`). + let param_ty = self.normalize_associated_types_in(param_ty); + let expected = Expectation::rvalue_hint(&mut self.table, expected_ty); + // infer with the expected type we have... + let ty = self.infer_expr_inner(arg, &expected); + + // then coerce to either the expected type or just the formal parameter type + let coercion_target = if let Some(ty) = expected.only_has_type(&mut self.table) { + // if we are coercing to the expectation, unify with the + // formal parameter type to connect everything + self.unify(&ty, ¶m_ty); + ty + } else { + param_ty + }; + if !coercion_target.is_unknown() { + if self.coerce(Some(arg), &ty, &coercion_target).is_err() { + self.result.type_mismatches.insert( + arg.into(), + TypeMismatch { expected: coercion_target, actual: ty.clone() }, + ); + } + } + } + } + } + + fn substs_for_method_call( + &mut self, + def_generics: Generics, + generic_args: Option<&GenericArgs>, + ) -> Substitution { + let (parent_params, self_params, type_params, const_params, impl_trait_params) = + def_generics.provenance_split(); + assert_eq!(self_params, 0); // method shouldn't have another Self param + let total_len = parent_params + type_params + const_params + impl_trait_params; + let mut substs = Vec::with_capacity(total_len); + // Parent arguments are unknown + for (id, param) in def_generics.iter_parent() { + match param { + TypeOrConstParamData::TypeParamData(_) => { + substs.push(GenericArgData::Ty(self.table.new_type_var()).intern(Interner)); + } + TypeOrConstParamData::ConstParamData(_) => { + let ty = self.db.const_param_ty(ConstParamId::from_unchecked(id)); + substs + .push(GenericArgData::Const(self.table.new_const_var(ty)).intern(Interner)); + } + } + } + // handle provided arguments + if let Some(generic_args) = generic_args { + // if args are provided, it should be all of them, but we can't rely on that + for (arg, kind_id) in generic_args + .args + .iter() + .filter(|arg| !matches!(arg, GenericArg::Lifetime(_))) + .take(type_params + const_params) + .zip(def_generics.iter_id().skip(parent_params)) + { + if let Some(g) = generic_arg_to_chalk( + self.db, + kind_id, + arg, + self, + |this, type_ref| this.make_ty(type_ref), + |this, c, ty| { + const_or_path_to_chalk( + this.db, + &this.resolver, + ty, + c, + ParamLoweringMode::Placeholder, + || generics(this.db.upcast(), (&this.resolver).generic_def().unwrap()), + DebruijnIndex::INNERMOST, + ) + }, + ) { + substs.push(g); + } + } + }; + for (id, data) in def_generics.iter().skip(substs.len()) { + match data { + TypeOrConstParamData::TypeParamData(_) => { + substs.push(GenericArgData::Ty(self.table.new_type_var()).intern(Interner)) + } + TypeOrConstParamData::ConstParamData(_) => { + substs.push( + GenericArgData::Const(self.table.new_const_var( + self.db.const_param_ty(ConstParamId::from_unchecked(id)), + )) + .intern(Interner), + ) + } + } + } + assert_eq!(substs.len(), total_len); + Substitution::from_iter(Interner, substs) + } + + fn register_obligations_for_call(&mut self, callable_ty: &Ty) { + let callable_ty = self.resolve_ty_shallow(callable_ty); + if let TyKind::FnDef(fn_def, parameters) = callable_ty.kind(Interner) { + let def: CallableDefId = from_chalk(self.db, *fn_def); + let generic_predicates = self.db.generic_predicates(def.into()); + for predicate in generic_predicates.iter() { + let (predicate, binders) = predicate + .clone() + .substitute(Interner, parameters) + .into_value_and_skipped_binders(); + always!(binders.len(Interner) == 0); // quantified where clauses not yet handled + self.push_obligation(predicate.cast(Interner)); + } + // add obligation for trait implementation, if this is a trait method + match def { + CallableDefId::FunctionId(f) => { + if let ItemContainerId::TraitId(trait_) = f.lookup(self.db.upcast()).container { + // construct a TraitRef + let substs = crate::subst_prefix( + &*parameters, + generics(self.db.upcast(), trait_.into()).len(), + ); + self.push_obligation( + TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs } + .cast(Interner), + ); + } + } + CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {} + } + } + } + + /// Returns the argument indices to skip. + fn check_legacy_const_generics(&mut self, callee: Ty, args: &[ExprId]) -> Box<[u32]> { + let (func, subst) = match callee.kind(Interner) { + TyKind::FnDef(fn_id, subst) => { + let callable = CallableDefId::from_chalk(self.db, *fn_id); + let func = match callable { + CallableDefId::FunctionId(f) => f, + _ => return Default::default(), + }; + (func, subst) + } + _ => return Default::default(), + }; + + let data = self.db.function_data(func); + if data.legacy_const_generics_indices.is_empty() { + return Default::default(); + } + + // only use legacy const generics if the param count matches with them + if data.params.len() + data.legacy_const_generics_indices.len() != args.len() { + if args.len() <= data.params.len() { + return Default::default(); + } else { + // there are more parameters than there should be without legacy + // const params; use them + let mut indices = data.legacy_const_generics_indices.clone(); + indices.sort(); + return indices; + } + } + + // check legacy const parameters + for (subst_idx, arg_idx) in data.legacy_const_generics_indices.iter().copied().enumerate() { + let arg = match subst.at(Interner, subst_idx).constant(Interner) { + Some(c) => c, + None => continue, // not a const parameter? + }; + if arg_idx >= args.len() as u32 { + continue; + } + let _ty = arg.data(Interner).ty.clone(); + let expected = Expectation::none(); // FIXME use actual const ty, when that is lowered correctly + self.infer_expr(args[arg_idx as usize], &expected); + // FIXME: evaluate and unify with the const + } + let mut indices = data.legacy_const_generics_indices.clone(); + indices.sort(); + indices + } + + fn builtin_binary_op_return_ty(&mut self, op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Option<Ty> { + let lhs_ty = self.resolve_ty_shallow(&lhs_ty); + let rhs_ty = self.resolve_ty_shallow(&rhs_ty); + match op { + BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => { + Some(TyKind::Scalar(Scalar::Bool).intern(Interner)) + } + BinaryOp::Assignment { .. } => Some(TyBuilder::unit()), + BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr) => { + // all integer combinations are valid here + if matches!( + lhs_ty.kind(Interner), + TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_)) + | TyKind::InferenceVar(_, TyVariableKind::Integer) + ) && matches!( + rhs_ty.kind(Interner), + TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_)) + | TyKind::InferenceVar(_, TyVariableKind::Integer) + ) { + Some(lhs_ty) + } else { + None + } + } + BinaryOp::ArithOp(_) => match (lhs_ty.kind(Interner), rhs_ty.kind(Interner)) { + // (int, int) | (uint, uint) | (float, float) + (TyKind::Scalar(Scalar::Int(_)), TyKind::Scalar(Scalar::Int(_))) + | (TyKind::Scalar(Scalar::Uint(_)), TyKind::Scalar(Scalar::Uint(_))) + | (TyKind::Scalar(Scalar::Float(_)), TyKind::Scalar(Scalar::Float(_))) => { + Some(rhs_ty) + } + // ({int}, int) | ({int}, uint) + ( + TyKind::InferenceVar(_, TyVariableKind::Integer), + TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_)), + ) => Some(rhs_ty), + // (int, {int}) | (uint, {int}) + ( + TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_)), + TyKind::InferenceVar(_, TyVariableKind::Integer), + ) => Some(lhs_ty), + // ({float} | float) + ( + TyKind::InferenceVar(_, TyVariableKind::Float), + TyKind::Scalar(Scalar::Float(_)), + ) => Some(rhs_ty), + // (float, {float}) + ( + TyKind::Scalar(Scalar::Float(_)), + TyKind::InferenceVar(_, TyVariableKind::Float), + ) => Some(lhs_ty), + // ({int}, {int}) | ({float}, {float}) + ( + TyKind::InferenceVar(_, TyVariableKind::Integer), + TyKind::InferenceVar(_, TyVariableKind::Integer), + ) + | ( + TyKind::InferenceVar(_, TyVariableKind::Float), + TyKind::InferenceVar(_, TyVariableKind::Float), + ) => Some(rhs_ty), + _ => None, + }, + } + } + + fn builtin_binary_op_rhs_expectation(&mut self, op: BinaryOp, lhs_ty: Ty) -> Option<Ty> { + Some(match op { + BinaryOp::LogicOp(..) => TyKind::Scalar(Scalar::Bool).intern(Interner), + BinaryOp::Assignment { op: None } => lhs_ty, + BinaryOp::CmpOp(CmpOp::Eq { .. }) => match self + .resolve_ty_shallow(&lhs_ty) + .kind(Interner) + { + TyKind::Scalar(_) | TyKind::Str => lhs_ty, + TyKind::InferenceVar(_, TyVariableKind::Integer | TyVariableKind::Float) => lhs_ty, + _ => return None, + }, + BinaryOp::ArithOp(ArithOp::Shl | ArithOp::Shr) => return None, + BinaryOp::CmpOp(CmpOp::Ord { .. }) + | BinaryOp::Assignment { op: Some(_) } + | BinaryOp::ArithOp(_) => match self.resolve_ty_shallow(&lhs_ty).kind(Interner) { + TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_)) => lhs_ty, + TyKind::InferenceVar(_, TyVariableKind::Integer | TyVariableKind::Float) => lhs_ty, + _ => return None, + }, + }) + } + + fn resolve_binop_method(&self, op: BinaryOp) -> Option<FunctionId> { + let (name, lang_item) = match op { + BinaryOp::LogicOp(_) => return None, + BinaryOp::ArithOp(aop) => match aop { + ArithOp::Add => (name!(add), name!(add)), + ArithOp::Mul => (name!(mul), name!(mul)), + ArithOp::Sub => (name!(sub), name!(sub)), + ArithOp::Div => (name!(div), name!(div)), + ArithOp::Rem => (name!(rem), name!(rem)), + ArithOp::Shl => (name!(shl), name!(shl)), + ArithOp::Shr => (name!(shr), name!(shr)), + ArithOp::BitXor => (name!(bitxor), name!(bitxor)), + ArithOp::BitOr => (name!(bitor), name!(bitor)), + ArithOp::BitAnd => (name!(bitand), name!(bitand)), + }, + BinaryOp::Assignment { op: Some(aop) } => match aop { + ArithOp::Add => (name!(add_assign), name!(add_assign)), + ArithOp::Mul => (name!(mul_assign), name!(mul_assign)), + ArithOp::Sub => (name!(sub_assign), name!(sub_assign)), + ArithOp::Div => (name!(div_assign), name!(div_assign)), + ArithOp::Rem => (name!(rem_assign), name!(rem_assign)), + ArithOp::Shl => (name!(shl_assign), name!(shl_assign)), + ArithOp::Shr => (name!(shr_assign), name!(shr_assign)), + ArithOp::BitXor => (name!(bitxor_assign), name!(bitxor_assign)), + ArithOp::BitOr => (name!(bitor_assign), name!(bitor_assign)), + ArithOp::BitAnd => (name!(bitand_assign), name!(bitand_assign)), + }, + BinaryOp::CmpOp(cop) => match cop { + CmpOp::Eq { negated: false } => (name!(eq), name!(eq)), + CmpOp::Eq { negated: true } => (name!(ne), name!(eq)), + CmpOp::Ord { ordering: Ordering::Less, strict: false } => { + (name!(le), name!(partial_ord)) + } + CmpOp::Ord { ordering: Ordering::Less, strict: true } => { + (name!(lt), name!(partial_ord)) + } + CmpOp::Ord { ordering: Ordering::Greater, strict: false } => { + (name!(ge), name!(partial_ord)) + } + CmpOp::Ord { ordering: Ordering::Greater, strict: true } => { + (name!(gt), name!(partial_ord)) + } + }, + BinaryOp::Assignment { op: None } => return None, + }; + + let trait_ = self.resolve_lang_item(lang_item)?.as_trait()?; + + self.db.trait_data(trait_).method_by_name(&name) + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs new file mode 100644 index 000000000..5e7320a5d --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs @@ -0,0 +1,354 @@ +//! Type inference for patterns. + +use std::iter::repeat_with; + +use chalk_ir::Mutability; +use hir_def::{ + expr::{BindingAnnotation, Expr, Literal, Pat, PatId}, + path::Path, + type_ref::ConstScalar, +}; +use hir_expand::name::Name; + +use crate::{ + consteval::intern_const_scalar, + infer::{BindingMode, Expectation, InferenceContext, TypeMismatch}, + lower::lower_to_chalk_mutability, + static_lifetime, ConcreteConst, ConstValue, Interner, Substitution, Ty, TyBuilder, TyExt, + TyKind, +}; + +use super::PatLike; + +impl<'a> InferenceContext<'a> { + /// Infers type for tuple struct pattern or its corresponding assignee expression. + /// + /// Ellipses found in the original pattern or expression must be filtered out. + pub(super) fn infer_tuple_struct_pat_like<T: PatLike>( + &mut self, + path: Option<&Path>, + expected: &Ty, + default_bm: T::BindingMode, + id: T, + ellipsis: Option<usize>, + subs: &[T], + ) -> Ty { + let (ty, def) = self.resolve_variant(path, true); + let var_data = def.map(|it| it.variant_data(self.db.upcast())); + if let Some(variant) = def { + self.write_variant_resolution(id.into(), variant); + } + self.unify(&ty, expected); + + let substs = + ty.as_adt().map(|(_, s)| s.clone()).unwrap_or_else(|| Substitution::empty(Interner)); + + let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default(); + let (pre, post) = match ellipsis { + Some(idx) => subs.split_at(idx), + None => (subs, &[][..]), + }; + let post_idx_offset = field_tys.iter().count().saturating_sub(post.len()); + + let pre_iter = pre.iter().enumerate(); + let post_iter = (post_idx_offset..).zip(post.iter()); + for (i, &subpat) in pre_iter.chain(post_iter) { + let expected_ty = var_data + .as_ref() + .and_then(|d| d.field(&Name::new_tuple_field(i))) + .map_or(self.err_ty(), |field| { + field_tys[field].clone().substitute(Interner, &substs) + }); + let expected_ty = self.normalize_associated_types_in(expected_ty); + T::infer(self, subpat, &expected_ty, default_bm); + } + + ty + } + + /// Infers type for record pattern or its corresponding assignee expression. + pub(super) fn infer_record_pat_like<T: PatLike>( + &mut self, + path: Option<&Path>, + expected: &Ty, + default_bm: T::BindingMode, + id: T, + subs: impl Iterator<Item = (Name, T)>, + ) -> Ty { + let (ty, def) = self.resolve_variant(path, false); + if let Some(variant) = def { + self.write_variant_resolution(id.into(), variant); + } + + self.unify(&ty, expected); + + let substs = + ty.as_adt().map(|(_, s)| s.clone()).unwrap_or_else(|| Substitution::empty(Interner)); + + let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default(); + let var_data = def.map(|it| it.variant_data(self.db.upcast())); + + for (name, inner) in subs { + let expected_ty = var_data + .as_ref() + .and_then(|it| it.field(&name)) + .map_or(self.err_ty(), |f| field_tys[f].clone().substitute(Interner, &substs)); + let expected_ty = self.normalize_associated_types_in(expected_ty); + + T::infer(self, inner, &expected_ty, default_bm); + } + + ty + } + + /// Infers type for tuple pattern or its corresponding assignee expression. + /// + /// Ellipses found in the original pattern or expression must be filtered out. + pub(super) fn infer_tuple_pat_like<T: PatLike>( + &mut self, + expected: &Ty, + default_bm: T::BindingMode, + ellipsis: Option<usize>, + subs: &[T], + ) -> Ty { + let expectations = match expected.as_tuple() { + Some(parameters) => &*parameters.as_slice(Interner), + _ => &[], + }; + + let ((pre, post), n_uncovered_patterns) = match ellipsis { + Some(idx) => (subs.split_at(idx), expectations.len().saturating_sub(subs.len())), + None => ((&subs[..], &[][..]), 0), + }; + let mut expectations_iter = expectations + .iter() + .cloned() + .map(|a| a.assert_ty_ref(Interner).clone()) + .chain(repeat_with(|| self.table.new_type_var())); + + let mut inner_tys = Vec::with_capacity(n_uncovered_patterns + subs.len()); + + inner_tys.extend(expectations_iter.by_ref().take(n_uncovered_patterns + subs.len())); + + // Process pre + for (ty, pat) in inner_tys.iter_mut().zip(pre) { + *ty = T::infer(self, *pat, ty, default_bm); + } + + // Process post + for (ty, pat) in inner_tys.iter_mut().skip(pre.len() + n_uncovered_patterns).zip(post) { + *ty = T::infer(self, *pat, ty, default_bm); + } + + TyKind::Tuple(inner_tys.len(), Substitution::from_iter(Interner, inner_tys)) + .intern(Interner) + } + + pub(super) fn infer_pat( + &mut self, + pat: PatId, + expected: &Ty, + mut default_bm: BindingMode, + ) -> Ty { + let mut expected = self.resolve_ty_shallow(expected); + + if is_non_ref_pat(&self.body, pat) { + let mut pat_adjustments = Vec::new(); + while let Some((inner, _lifetime, mutability)) = expected.as_reference() { + pat_adjustments.push(expected.clone()); + expected = self.resolve_ty_shallow(inner); + default_bm = match default_bm { + BindingMode::Move => BindingMode::Ref(mutability), + BindingMode::Ref(Mutability::Not) => BindingMode::Ref(Mutability::Not), + BindingMode::Ref(Mutability::Mut) => BindingMode::Ref(mutability), + } + } + + if !pat_adjustments.is_empty() { + pat_adjustments.shrink_to_fit(); + self.result.pat_adjustments.insert(pat, pat_adjustments); + } + } else if let Pat::Ref { .. } = &self.body[pat] { + cov_mark::hit!(match_ergonomics_ref); + // When you encounter a `&pat` pattern, reset to Move. + // This is so that `w` is by value: `let (_, &w) = &(1, &2);` + default_bm = BindingMode::Move; + } + + // Lose mutability. + let default_bm = default_bm; + let expected = expected; + + let ty = match &self.body[pat] { + Pat::Tuple { args, ellipsis } => { + self.infer_tuple_pat_like(&expected, default_bm, *ellipsis, args) + } + Pat::Or(pats) => { + if let Some((first_pat, rest)) = pats.split_first() { + let ty = self.infer_pat(*first_pat, &expected, default_bm); + for pat in rest { + self.infer_pat(*pat, &expected, default_bm); + } + ty + } else { + self.err_ty() + } + } + Pat::Ref { pat, mutability } => { + let mutability = lower_to_chalk_mutability(*mutability); + let expectation = match expected.as_reference() { + Some((inner_ty, _lifetime, exp_mut)) => { + if mutability != exp_mut { + // FIXME: emit type error? + } + inner_ty.clone() + } + _ => self.result.standard_types.unknown.clone(), + }; + let subty = self.infer_pat(*pat, &expectation, default_bm); + TyKind::Ref(mutability, static_lifetime(), subty).intern(Interner) + } + Pat::TupleStruct { path: p, args: subpats, ellipsis } => self + .infer_tuple_struct_pat_like( + p.as_deref(), + &expected, + default_bm, + pat, + *ellipsis, + subpats, + ), + Pat::Record { path: p, args: fields, ellipsis: _ } => { + let subs = fields.iter().map(|f| (f.name.clone(), f.pat)); + self.infer_record_pat_like(p.as_deref(), &expected, default_bm, pat.into(), subs) + } + Pat::Path(path) => { + // FIXME use correct resolver for the surrounding expression + let resolver = self.resolver.clone(); + self.infer_path(&resolver, path, pat.into()).unwrap_or_else(|| self.err_ty()) + } + Pat::Bind { mode, name: _, subpat } => { + let mode = if mode == &BindingAnnotation::Unannotated { + default_bm + } else { + BindingMode::convert(*mode) + }; + self.result.pat_binding_modes.insert(pat, mode); + + let inner_ty = match subpat { + Some(subpat) => self.infer_pat(*subpat, &expected, default_bm), + None => expected, + }; + let inner_ty = self.insert_type_vars_shallow(inner_ty); + + let bound_ty = match mode { + BindingMode::Ref(mutability) => { + TyKind::Ref(mutability, static_lifetime(), inner_ty.clone()) + .intern(Interner) + } + BindingMode::Move => inner_ty.clone(), + }; + self.write_pat_ty(pat, bound_ty); + return inner_ty; + } + Pat::Slice { prefix, slice, suffix } => { + let elem_ty = match expected.kind(Interner) { + TyKind::Array(st, _) | TyKind::Slice(st) => st.clone(), + _ => self.err_ty(), + }; + + for &pat_id in prefix.iter().chain(suffix.iter()) { + self.infer_pat(pat_id, &elem_ty, default_bm); + } + + if let &Some(slice_pat_id) = slice { + let rest_pat_ty = match expected.kind(Interner) { + TyKind::Array(_, length) => { + let len = match length.data(Interner).value { + ConstValue::Concrete(ConcreteConst { + interned: ConstScalar::UInt(len), + }) => len.checked_sub((prefix.len() + suffix.len()) as u128), + _ => None, + }; + TyKind::Array( + elem_ty.clone(), + intern_const_scalar( + len.map_or(ConstScalar::Unknown, |len| ConstScalar::UInt(len)), + TyBuilder::usize(), + ), + ) + } + _ => TyKind::Slice(elem_ty.clone()), + } + .intern(Interner); + self.infer_pat(slice_pat_id, &rest_pat_ty, default_bm); + } + + match expected.kind(Interner) { + TyKind::Array(_, const_) => TyKind::Array(elem_ty, const_.clone()), + _ => TyKind::Slice(elem_ty), + } + .intern(Interner) + } + Pat::Wild => expected.clone(), + Pat::Range { start, end } => { + let start_ty = self.infer_expr(*start, &Expectation::has_type(expected.clone())); + self.infer_expr(*end, &Expectation::has_type(start_ty)) + } + Pat::Lit(expr) => self.infer_expr(*expr, &Expectation::has_type(expected.clone())), + Pat::Box { inner } => match self.resolve_boxed_box() { + Some(box_adt) => { + let (inner_ty, alloc_ty) = match expected.as_adt() { + Some((adt, subst)) if adt == box_adt => ( + subst.at(Interner, 0).assert_ty_ref(Interner).clone(), + subst.as_slice(Interner).get(1).and_then(|a| a.ty(Interner).cloned()), + ), + _ => (self.result.standard_types.unknown.clone(), None), + }; + + let inner_ty = self.infer_pat(*inner, &inner_ty, default_bm); + let mut b = TyBuilder::adt(self.db, box_adt).push(inner_ty); + + if let Some(alloc_ty) = alloc_ty { + b = b.push(alloc_ty); + } + b.fill_with_defaults(self.db, || self.table.new_type_var()).build() + } + None => self.err_ty(), + }, + Pat::ConstBlock(expr) => { + self.infer_expr(*expr, &Expectation::has_type(expected.clone())) + } + Pat::Missing => self.err_ty(), + }; + // use a new type variable if we got error type here + let ty = self.insert_type_vars_shallow(ty); + if !self.unify(&ty, &expected) { + self.result + .type_mismatches + .insert(pat.into(), TypeMismatch { expected, actual: ty.clone() }); + } + self.write_pat_ty(pat, ty.clone()); + ty + } +} + +fn is_non_ref_pat(body: &hir_def::body::Body, pat: PatId) -> bool { + match &body[pat] { + Pat::Tuple { .. } + | Pat::TupleStruct { .. } + | Pat::Record { .. } + | Pat::Range { .. } + | Pat::Slice { .. } => true, + Pat::Or(pats) => pats.iter().all(|p| is_non_ref_pat(body, *p)), + // FIXME: ConstBlock/Path/Lit might actually evaluate to ref, but inference is unimplemented. + Pat::Path(..) => true, + Pat::ConstBlock(..) => true, + Pat::Lit(expr) => !matches!(body[*expr], Expr::Literal(Literal::String(..))), + Pat::Bind { + mode: BindingAnnotation::Mutable | BindingAnnotation::Unannotated, + subpat: Some(subpat), + .. + } => is_non_ref_pat(body, *subpat), + Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Box { .. } | Pat::Missing => false, + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs new file mode 100644 index 000000000..f580e09e9 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs @@ -0,0 +1,295 @@ +//! Path expression resolution. + +use chalk_ir::cast::Cast; +use hir_def::{ + path::{Path, PathSegment}, + resolver::{ResolveValueResult, Resolver, TypeNs, ValueNs}, + AdtId, AssocItemId, EnumVariantId, ItemContainerId, Lookup, +}; +use hir_expand::name::Name; + +use crate::{ + builder::ParamKind, + consteval, + method_resolution::{self, VisibleFromModule}, + GenericArgData, Interner, Substitution, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, + ValueTyDefId, +}; + +use super::{ExprOrPatId, InferenceContext, TraitRef}; + +impl<'a> InferenceContext<'a> { + 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 Some(type_ref) = path.type_anchor() { + 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().take(path.segments().len() - 1); + let ctx = crate::lower::TyLoweringContext::new(self.db, resolver); + let (ty, _) = ctx.lower_ty_relative_path(ty, None, remaining_segments_for_ty); + self.resolve_ty_assoc_item( + ty, + path.segments().last().expect("path had at least one segment").name, + id, + )? + } else { + let value_or_partial = + resolver.resolve_path_in_value_ns(self.db.upcast(), path.mod_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: ValueTyDefId = match value { + ValueNs::LocalBinding(pat) => { + let ty = self.result.type_of_pat.get(pat)?.clone(); + return Some(ty); + } + ValueNs::FunctionId(it) => it.into(), + ValueNs::ConstId(it) => it.into(), + ValueNs::StaticId(it) => it.into(), + ValueNs::StructId(it) => { + self.write_variant_resolution(id, it.into()); + + it.into() + } + ValueNs::EnumVariantId(it) => { + self.write_variant_resolution(id, it.into()); + + it.into() + } + ValueNs::ImplSelf(impl_id) => { + let generics = crate::utils::generics(self.db.upcast(), impl_id.into()); + let substs = generics.placeholder_subst(self.db); + let ty = self.db.impl_self_ty(impl_id).substitute(Interner, &substs); + if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() { + let ty = self.db.value_ty(struct_id.into()).substitute(Interner, &substs); + return Some(ty); + } else { + // FIXME: diagnostic, invalid Self reference + return None; + } + } + ValueNs::GenericParam(it) => return Some(self.db.const_param_ty(it)), + }; + + let parent_substs = self_subst.unwrap_or_else(|| Substitution::empty(Interner)); + let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); + let substs = ctx.substs_from_path(path, typable, true); + let mut it = substs.as_slice(Interner)[parent_substs.len(Interner)..].iter().cloned(); + let ty = TyBuilder::value_ty(self.db, typable) + .use_parent_substs(&parent_substs) + .fill(|x| { + it.next().unwrap_or_else(|| match x { + ParamKind::Type => { + GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner) + } + ParamKind::Const(ty) => consteval::unknown_const_as_generic(ty.clone()), + }) + }) + .build(); + Some(ty) + } + + fn resolve_assoc_item( + &mut self, + def: TypeNs, + path: &Path, + remaining_index: usize, + id: ExprOrPatId, + ) -> Option<(ValueNs, Option<Substitution>)> { + 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().get(remaining_index - 1).unwrap(); + let remaining_segments = path.segments().skip(remaining_index); + let is_before_last = remaining_segments.len() == 1; + + match (def, is_before_last) { + (TypeNs::TraitId(trait_), true) => { + let segment = + remaining_segments.last().expect("there should be at least one segment here"); + let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); + let trait_ref = + ctx.lower_trait_ref_from_resolved_path(trait_, resolved_segment, None); + self.resolve_trait_assoc_item(trait_ref, segment, id) + } + (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.take(remaining_segments.len() - 1); + let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver); + let (ty, _) = ctx.lower_partly_resolved_path( + def, + resolved_segment, + remaining_segments_for_ty, + true, + ); + if let TyKind::Error = ty.kind(Interner) { + return None; + } + + let ty = self.insert_type_vars(ty); + let ty = self.normalize_associated_types_in(ty); + + let segment = + remaining_segments.last().expect("there should be at least one segment here"); + + self.resolve_ty_assoc_item(ty, segment.name, id) + } + } + } + + fn resolve_trait_assoc_item( + &mut self, + trait_ref: TraitRef, + segment: PathSegment<'_>, + id: ExprOrPatId, + ) -> Option<(ValueNs, Option<Substitution>)> { + let trait_ = trait_ref.hir_trait_id(); + let item = + self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|item| { + match item { + AssocItemId::FunctionId(func) => { + if segment.name == &self.db.function_data(func).name { + Some(AssocItemId::FunctionId(func)) + } else { + None + } + } + + AssocItemId::ConstId(konst) => { + if self + .db + .const_data(konst) + .name + .as_ref() + .map_or(false, |n| n == segment.name) + { + Some(AssocItemId::ConstId(konst)) + } else { + None + } + } + AssocItemId::TypeAliasId(_) => None, + } + })?; + let def = match item { + AssocItemId::FunctionId(f) => ValueNs::FunctionId(f), + AssocItemId::ConstId(c) => ValueNs::ConstId(c), + AssocItemId::TypeAliasId(_) => unreachable!(), + }; + + self.write_assoc_resolution(id, item); + Some((def, Some(trait_ref.substitution))) + } + + fn resolve_ty_assoc_item( + &mut self, + ty: Ty, + name: &Name, + id: ExprOrPatId, + ) -> Option<(ValueNs, Option<Substitution>)> { + if let TyKind::Error = ty.kind(Interner) { + return None; + } + + if let Some(result) = self.resolve_enum_variant_on_ty(&ty, name, id) { + return Some(result); + } + + let canonical_ty = self.canonicalize(ty.clone()); + let traits_in_scope = self.resolver.traits_in_scope(self.db.upcast()); + + method_resolution::iterate_method_candidates( + &canonical_ty.value, + self.db, + self.table.trait_env.clone(), + &traits_in_scope, + VisibleFromModule::Filter(self.resolver.module()), + Some(name), + method_resolution::LookupMode::Path, + move |_ty, item| { + let (def, container) = match item { + AssocItemId::FunctionId(f) => { + (ValueNs::FunctionId(f), f.lookup(self.db.upcast()).container) + } + AssocItemId::ConstId(c) => { + (ValueNs::ConstId(c), c.lookup(self.db.upcast()).container) + } + AssocItemId::TypeAliasId(_) => unreachable!(), + }; + let substs = match container { + ItemContainerId::ImplId(impl_id) => { + let impl_substs = TyBuilder::subst_for_def(self.db, impl_id) + .fill_with_inference_vars(&mut self.table) + .build(); + let impl_self_ty = + self.db.impl_self_ty(impl_id).substitute(Interner, &impl_substs); + self.unify(&impl_self_ty, &ty); + Some(impl_substs) + } + ItemContainerId::TraitId(trait_) => { + // we're picking this method + let trait_ref = TyBuilder::trait_ref(self.db, trait_) + .push(ty.clone()) + .fill_with_inference_vars(&mut self.table) + .build(); + self.push_obligation(trait_ref.clone().cast(Interner)); + Some(trait_ref.substitution) + } + ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None, + }; + + self.write_assoc_resolution(id, item); + Some((def, substs)) + }, + ) + } + + fn resolve_enum_variant_on_ty( + &mut self, + ty: &Ty, + name: &Name, + id: ExprOrPatId, + ) -> Option<(ValueNs, Option<Substitution>)> { + let ty = self.resolve_ty_shallow(ty); + let (enum_id, subst) = match ty.as_adt() { + Some((AdtId::EnumId(e), subst)) => (e, subst), + _ => return None, + }; + let enum_data = self.db.enum_data(enum_id); + let local_id = enum_data.variant(name)?; + let variant = EnumVariantId { parent: enum_id, local_id }; + self.write_variant_resolution(id, variant.into()); + Some((ValueNs::EnumVariantId(variant), Some(subst.clone()))) + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs new file mode 100644 index 000000000..e77b55670 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs @@ -0,0 +1,738 @@ +//! Unification and canonicalization logic. + +use std::{fmt, mem, sync::Arc}; + +use chalk_ir::{ + cast::Cast, fold::TypeFoldable, interner::HasInterner, zip::Zip, CanonicalVarKind, FloatTy, + IntTy, NoSolution, TyVariableKind, UniverseIndex, +}; +use chalk_solve::infer::ParameterEnaVariableExt; +use ena::unify::UnifyKey; +use hir_expand::name; +use stdx::never; + +use super::{InferOk, InferResult, InferenceContext, TypeError}; +use crate::{ + db::HirDatabase, fold_tys, static_lifetime, traits::FnTrait, AliasEq, AliasTy, BoundVar, + Canonical, Const, DebruijnIndex, GenericArg, GenericArgData, Goal, Guidance, InEnvironment, + InferenceVar, Interner, Lifetime, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Solution, + Substitution, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind, VariableKind, +}; + +impl<'a> InferenceContext<'a> { + pub(super) fn canonicalize<T: TypeFoldable<Interner> + HasInterner<Interner = Interner>>( + &mut self, + t: T, + ) -> Canonicalized<T> + where + T: HasInterner<Interner = Interner>, + { + self.table.canonicalize(t) + } +} + +#[derive(Debug, Clone)] +pub(crate) struct Canonicalized<T> +where + T: HasInterner<Interner = Interner>, +{ + pub(crate) value: Canonical<T>, + free_vars: Vec<GenericArg>, +} + +impl<T: HasInterner<Interner = Interner>> Canonicalized<T> { + pub(super) fn apply_solution( + &self, + ctx: &mut InferenceTable<'_>, + solution: Canonical<Substitution>, + ) { + // the solution may contain new variables, which we need to convert to new inference vars + let new_vars = Substitution::from_iter( + Interner, + solution.binders.iter(Interner).map(|k| match &k.kind { + VariableKind::Ty(TyVariableKind::General) => ctx.new_type_var().cast(Interner), + VariableKind::Ty(TyVariableKind::Integer) => ctx.new_integer_var().cast(Interner), + VariableKind::Ty(TyVariableKind::Float) => ctx.new_float_var().cast(Interner), + // Chalk can sometimes return new lifetime variables. We just use the static lifetime everywhere + VariableKind::Lifetime => static_lifetime().cast(Interner), + VariableKind::Const(ty) => ctx.new_const_var(ty.clone()).cast(Interner), + }), + ); + for (i, v) in solution.value.iter(Interner).enumerate() { + let var = self.free_vars[i].clone(); + if let Some(ty) = v.ty(Interner) { + // eagerly replace projections in the type; we may be getting types + // e.g. from where clauses where this hasn't happened yet + let ty = ctx.normalize_associated_types_in(new_vars.apply(ty.clone(), Interner)); + ctx.unify(var.assert_ty_ref(Interner), &ty); + } else { + let _ = ctx.try_unify(&var, &new_vars.apply(v.clone(), Interner)); + } + } + } +} + +pub fn could_unify( + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + tys: &Canonical<(Ty, Ty)>, +) -> bool { + unify(db, env, tys).is_some() +} + +pub(crate) fn unify( + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + tys: &Canonical<(Ty, Ty)>, +) -> Option<Substitution> { + let mut table = InferenceTable::new(db, env); + let vars = Substitution::from_iter( + Interner, + tys.binders.iter(Interner).map(|x| match &x.kind { + chalk_ir::VariableKind::Ty(_) => { + GenericArgData::Ty(table.new_type_var()).intern(Interner) + } + chalk_ir::VariableKind::Lifetime => { + GenericArgData::Ty(table.new_type_var()).intern(Interner) + } // FIXME: maybe wrong? + chalk_ir::VariableKind::Const(ty) => { + GenericArgData::Const(table.new_const_var(ty.clone())).intern(Interner) + } + }), + ); + let ty1_with_vars = vars.apply(tys.value.0.clone(), Interner); + let ty2_with_vars = vars.apply(tys.value.1.clone(), Interner); + if !table.unify(&ty1_with_vars, &ty2_with_vars) { + return None; + } + // default any type vars that weren't unified back to their original bound vars + // (kind of hacky) + let find_var = |iv| { + vars.iter(Interner).position(|v| match v.interned() { + chalk_ir::GenericArgData::Ty(ty) => ty.inference_var(Interner), + chalk_ir::GenericArgData::Lifetime(lt) => lt.inference_var(Interner), + chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner), + } == Some(iv)) + }; + let fallback = |iv, kind, default, binder| match kind { + chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv) + .map_or(default, |i| BoundVar::new(binder, i).to_ty(Interner).cast(Interner)), + chalk_ir::VariableKind::Lifetime => find_var(iv) + .map_or(default, |i| BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner)), + chalk_ir::VariableKind::Const(ty) => find_var(iv) + .map_or(default, |i| BoundVar::new(binder, i).to_const(Interner, ty).cast(Interner)), + }; + Some(Substitution::from_iter( + Interner, + vars.iter(Interner).map(|v| table.resolve_with_fallback(v.clone(), &fallback)), + )) +} + +#[derive(Copy, Clone, Debug)] +pub(crate) struct TypeVariableData { + diverging: bool, +} + +type ChalkInferenceTable = chalk_solve::infer::InferenceTable<Interner>; + +#[derive(Clone)] +pub(crate) struct InferenceTable<'a> { + pub(crate) db: &'a dyn HirDatabase, + pub(crate) trait_env: Arc<TraitEnvironment>, + var_unification_table: ChalkInferenceTable, + type_variable_table: Vec<TypeVariableData>, + pending_obligations: Vec<Canonicalized<InEnvironment<Goal>>>, +} + +pub(crate) struct InferenceTableSnapshot { + var_table_snapshot: chalk_solve::infer::InferenceSnapshot<Interner>, + pending_obligations: Vec<Canonicalized<InEnvironment<Goal>>>, + type_variable_table_snapshot: Vec<TypeVariableData>, +} + +impl<'a> InferenceTable<'a> { + pub(crate) fn new(db: &'a dyn HirDatabase, trait_env: Arc<TraitEnvironment>) -> Self { + InferenceTable { + db, + trait_env, + var_unification_table: ChalkInferenceTable::new(), + type_variable_table: Vec::new(), + pending_obligations: Vec::new(), + } + } + + /// Chalk doesn't know about the `diverging` flag, so when it unifies two + /// type variables of which one is diverging, the chosen root might not be + /// diverging and we have no way of marking it as such at that time. This + /// function goes through all type variables and make sure their root is + /// marked as diverging if necessary, so that resolving them gives the right + /// result. + pub(super) fn propagate_diverging_flag(&mut self) { + for i in 0..self.type_variable_table.len() { + if !self.type_variable_table[i].diverging { + continue; + } + let v = InferenceVar::from(i as u32); + let root = self.var_unification_table.inference_var_root(v); + if let Some(data) = self.type_variable_table.get_mut(root.index() as usize) { + data.diverging = true; + } + } + } + + pub(super) fn set_diverging(&mut self, iv: InferenceVar, diverging: bool) { + self.type_variable_table[iv.index() as usize].diverging = diverging; + } + + fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty { + match kind { + _ if self + .type_variable_table + .get(iv.index() as usize) + .map_or(false, |data| data.diverging) => + { + TyKind::Never + } + TyVariableKind::General => TyKind::Error, + TyVariableKind::Integer => TyKind::Scalar(Scalar::Int(IntTy::I32)), + TyVariableKind::Float => TyKind::Scalar(Scalar::Float(FloatTy::F64)), + } + .intern(Interner) + } + + pub(crate) fn canonicalize<T: TypeFoldable<Interner> + HasInterner<Interner = Interner>>( + &mut self, + t: T, + ) -> Canonicalized<T> + where + T: HasInterner<Interner = Interner>, + { + // try to resolve obligations before canonicalizing, since this might + // result in new knowledge about variables + self.resolve_obligations_as_possible(); + let result = self.var_unification_table.canonicalize(Interner, t); + let free_vars = result + .free_vars + .into_iter() + .map(|free_var| free_var.to_generic_arg(Interner)) + .collect(); + Canonicalized { value: result.quantified, free_vars } + } + + /// Recurses through the given type, normalizing associated types mentioned + /// in it by replacing them by type variables and registering obligations to + /// resolve later. This should be done once for every type we get from some + /// type annotation (e.g. from a let type annotation, field type or function + /// call). `make_ty` handles this already, but e.g. for field types we need + /// to do it as well. + pub(crate) fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty { + fold_tys( + ty, + |ty, _| match ty.kind(Interner) { + TyKind::Alias(AliasTy::Projection(proj_ty)) => { + self.normalize_projection_ty(proj_ty.clone()) + } + _ => ty, + }, + DebruijnIndex::INNERMOST, + ) + } + + pub(crate) fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty { + let var = self.new_type_var(); + let alias_eq = AliasEq { alias: AliasTy::Projection(proj_ty), ty: var.clone() }; + let obligation = alias_eq.cast(Interner); + self.register_obligation(obligation); + var + } + + fn extend_type_variable_table(&mut self, to_index: usize) { + self.type_variable_table.extend( + (0..1 + to_index - self.type_variable_table.len()) + .map(|_| TypeVariableData { diverging: false }), + ); + } + + fn new_var(&mut self, kind: TyVariableKind, diverging: bool) -> Ty { + let var = self.var_unification_table.new_variable(UniverseIndex::ROOT); + // Chalk might have created some type variables for its own purposes that we don't know about... + self.extend_type_variable_table(var.index() as usize); + assert_eq!(var.index() as usize, self.type_variable_table.len() - 1); + self.type_variable_table[var.index() as usize].diverging = diverging; + var.to_ty_with_kind(Interner, kind) + } + + pub(crate) fn new_type_var(&mut self) -> Ty { + self.new_var(TyVariableKind::General, false) + } + + pub(crate) fn new_integer_var(&mut self) -> Ty { + self.new_var(TyVariableKind::Integer, false) + } + + pub(crate) fn new_float_var(&mut self) -> Ty { + self.new_var(TyVariableKind::Float, false) + } + + pub(crate) fn new_maybe_never_var(&mut self) -> Ty { + self.new_var(TyVariableKind::General, true) + } + + pub(crate) fn new_const_var(&mut self, ty: Ty) -> Const { + let var = self.var_unification_table.new_variable(UniverseIndex::ROOT); + var.to_const(Interner, ty) + } + + pub(crate) fn new_lifetime_var(&mut self) -> Lifetime { + let var = self.var_unification_table.new_variable(UniverseIndex::ROOT); + var.to_lifetime(Interner) + } + + pub(crate) fn resolve_with_fallback<T>( + &mut self, + t: T, + fallback: &dyn Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg, + ) -> T + where + T: HasInterner<Interner = Interner> + TypeFoldable<Interner>, + { + self.resolve_with_fallback_inner(&mut Vec::new(), t, &fallback) + } + + pub(crate) fn fresh_subst(&mut self, binders: &[CanonicalVarKind<Interner>]) -> Substitution { + Substitution::from_iter( + Interner, + binders.iter().map(|kind| { + let param_infer_var = + kind.map_ref(|&ui| self.var_unification_table.new_variable(ui)); + param_infer_var.to_generic_arg(Interner) + }), + ) + } + + pub(crate) fn instantiate_canonical<T>(&mut self, canonical: Canonical<T>) -> T + where + T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + std::fmt::Debug, + { + let subst = self.fresh_subst(canonical.binders.as_slice(Interner)); + subst.apply(canonical.value, Interner) + } + + fn resolve_with_fallback_inner<T>( + &mut self, + var_stack: &mut Vec<InferenceVar>, + t: T, + fallback: &dyn Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg, + ) -> T + where + T: HasInterner<Interner = Interner> + TypeFoldable<Interner>, + { + t.fold_with( + &mut resolve::Resolver { table: self, var_stack, fallback }, + DebruijnIndex::INNERMOST, + ) + .expect("fold failed unexpectedly") + } + + pub(crate) fn resolve_completely<T>(&mut self, t: T) -> T + where + T: HasInterner<Interner = Interner> + TypeFoldable<Interner>, + { + self.resolve_with_fallback(t, &|_, _, d, _| d) + } + + /// Unify two types and register new trait goals that arise from that. + pub(crate) fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool { + let result = match self.try_unify(ty1, ty2) { + Ok(r) => r, + Err(_) => return false, + }; + self.register_infer_ok(result); + true + } + + /// Unify two types and return new trait goals arising from it, so the + /// caller needs to deal with them. + pub(crate) fn try_unify<T: Zip<Interner>>(&mut self, t1: &T, t2: &T) -> InferResult<()> { + match self.var_unification_table.relate( + Interner, + &self.db, + &self.trait_env.env, + chalk_ir::Variance::Invariant, + t1, + t2, + ) { + Ok(result) => Ok(InferOk { goals: result.goals, value: () }), + Err(chalk_ir::NoSolution) => Err(TypeError), + } + } + + /// If `ty` is a type variable with known type, returns that type; + /// otherwise, return ty. + pub(crate) fn resolve_ty_shallow(&mut self, ty: &Ty) -> Ty { + self.resolve_obligations_as_possible(); + self.var_unification_table.normalize_ty_shallow(Interner, ty).unwrap_or_else(|| ty.clone()) + } + + pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot { + let var_table_snapshot = self.var_unification_table.snapshot(); + let type_variable_table_snapshot = self.type_variable_table.clone(); + let pending_obligations = self.pending_obligations.clone(); + InferenceTableSnapshot { + var_table_snapshot, + pending_obligations, + type_variable_table_snapshot, + } + } + + pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot) { + self.var_unification_table.rollback_to(snapshot.var_table_snapshot); + self.type_variable_table = snapshot.type_variable_table_snapshot; + self.pending_obligations = snapshot.pending_obligations; + } + + pub(crate) fn run_in_snapshot<T>(&mut self, f: impl FnOnce(&mut InferenceTable<'_>) -> T) -> T { + let snapshot = self.snapshot(); + let result = f(self); + self.rollback_to(snapshot); + result + } + + /// Checks an obligation without registering it. Useful mostly to check + /// whether a trait *might* be implemented before deciding to 'lock in' the + /// choice (during e.g. method resolution or deref). + pub(crate) fn try_obligation(&mut self, goal: Goal) -> Option<Solution> { + let in_env = InEnvironment::new(&self.trait_env.env, goal); + let canonicalized = self.canonicalize(in_env); + let solution = self.db.trait_solve(self.trait_env.krate, canonicalized.value); + solution + } + + pub(crate) fn register_obligation(&mut self, goal: Goal) { + let in_env = InEnvironment::new(&self.trait_env.env, goal); + self.register_obligation_in_env(in_env) + } + + fn register_obligation_in_env(&mut self, goal: InEnvironment<Goal>) { + let canonicalized = self.canonicalize(goal); + if !self.try_resolve_obligation(&canonicalized) { + self.pending_obligations.push(canonicalized); + } + } + + pub(crate) fn register_infer_ok<T>(&mut self, infer_ok: InferOk<T>) { + infer_ok.goals.into_iter().for_each(|goal| self.register_obligation_in_env(goal)); + } + + pub(crate) fn resolve_obligations_as_possible(&mut self) { + let _span = profile::span("resolve_obligations_as_possible"); + let mut changed = true; + let mut obligations = Vec::new(); + while changed { + changed = false; + mem::swap(&mut self.pending_obligations, &mut obligations); + for canonicalized in obligations.drain(..) { + if !self.check_changed(&canonicalized) { + self.pending_obligations.push(canonicalized); + continue; + } + changed = true; + let uncanonical = chalk_ir::Substitute::apply( + &canonicalized.free_vars, + canonicalized.value.value, + Interner, + ); + self.register_obligation_in_env(uncanonical); + } + } + } + + pub(crate) fn fudge_inference<T: TypeFoldable<Interner>>( + &mut self, + f: impl FnOnce(&mut Self) -> T, + ) -> T { + use chalk_ir::fold::TypeFolder; + struct VarFudger<'a, 'b> { + table: &'a mut InferenceTable<'b>, + highest_known_var: InferenceVar, + } + impl<'a, 'b> TypeFolder<Interner> for VarFudger<'a, 'b> { + type Error = NoSolution; + + fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner, Error = Self::Error> { + self + } + + fn interner(&self) -> Interner { + Interner + } + + fn fold_inference_ty( + &mut self, + var: chalk_ir::InferenceVar, + kind: TyVariableKind, + _outer_binder: chalk_ir::DebruijnIndex, + ) -> chalk_ir::Fallible<chalk_ir::Ty<Interner>> { + Ok(if var < self.highest_known_var { + var.to_ty(Interner, kind) + } else { + self.table.new_type_var() + }) + } + + fn fold_inference_lifetime( + &mut self, + var: chalk_ir::InferenceVar, + _outer_binder: chalk_ir::DebruijnIndex, + ) -> chalk_ir::Fallible<chalk_ir::Lifetime<Interner>> { + Ok(if var < self.highest_known_var { + var.to_lifetime(Interner) + } else { + self.table.new_lifetime_var() + }) + } + + fn fold_inference_const( + &mut self, + ty: chalk_ir::Ty<Interner>, + var: chalk_ir::InferenceVar, + _outer_binder: chalk_ir::DebruijnIndex, + ) -> chalk_ir::Fallible<chalk_ir::Const<Interner>> { + Ok(if var < self.highest_known_var { + var.to_const(Interner, ty) + } else { + self.table.new_const_var(ty) + }) + } + } + + let snapshot = self.snapshot(); + let highest_known_var = self.new_type_var().inference_var(Interner).expect("inference_var"); + let result = f(self); + self.rollback_to(snapshot); + result + .fold_with(&mut VarFudger { table: self, highest_known_var }, DebruijnIndex::INNERMOST) + .expect("fold_with with VarFudger") + } + + /// This checks whether any of the free variables in the `canonicalized` + /// have changed (either been unified with another variable, or with a + /// value). If this is not the case, we don't need to try to solve the goal + /// again -- it'll give the same result as last time. + fn check_changed(&mut self, canonicalized: &Canonicalized<InEnvironment<Goal>>) -> bool { + canonicalized.free_vars.iter().any(|var| { + let iv = match var.data(Interner) { + chalk_ir::GenericArgData::Ty(ty) => ty.inference_var(Interner), + chalk_ir::GenericArgData::Lifetime(lt) => lt.inference_var(Interner), + chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner), + } + .expect("free var is not inference var"); + if self.var_unification_table.probe_var(iv).is_some() { + return true; + } + let root = self.var_unification_table.inference_var_root(iv); + iv != root + }) + } + + fn try_resolve_obligation( + &mut self, + canonicalized: &Canonicalized<InEnvironment<Goal>>, + ) -> bool { + let solution = self.db.trait_solve(self.trait_env.krate, canonicalized.value.clone()); + + match solution { + Some(Solution::Unique(canonical_subst)) => { + canonicalized.apply_solution( + self, + Canonical { + binders: canonical_subst.binders, + // FIXME: handle constraints + value: canonical_subst.value.subst, + }, + ); + true + } + Some(Solution::Ambig(Guidance::Definite(substs))) => { + canonicalized.apply_solution(self, substs); + false + } + Some(_) => { + // FIXME use this when trying to resolve everything at the end + false + } + None => { + // FIXME obligation cannot be fulfilled => diagnostic + true + } + } + } + + pub(crate) fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> { + match ty.callable_sig(self.db) { + Some(sig) => Some((sig.params().to_vec(), sig.ret().clone())), + None => self.callable_sig_from_fn_trait(ty, num_args), + } + } + + fn callable_sig_from_fn_trait(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> { + let krate = self.trait_env.krate; + let fn_once_trait = FnTrait::FnOnce.get_id(self.db, krate)?; + let output_assoc_type = + self.db.trait_data(fn_once_trait).associated_type_by_name(&name![Output])?; + + let mut arg_tys = vec![]; + let arg_ty = TyBuilder::tuple(num_args) + .fill(|x| { + let arg = match x { + ParamKind::Type => self.new_type_var(), + ParamKind::Const(ty) => { + never!("Tuple with const parameter"); + return GenericArgData::Const(self.new_const_var(ty.clone())) + .intern(Interner); + } + }; + arg_tys.push(arg.clone()); + GenericArgData::Ty(arg).intern(Interner) + }) + .build(); + + let projection = { + let b = TyBuilder::assoc_type_projection(self.db, output_assoc_type); + if b.remaining() != 2 { + return None; + } + b.push(ty.clone()).push(arg_ty).build() + }; + + let trait_env = self.trait_env.env.clone(); + let obligation = InEnvironment { + goal: projection.trait_ref(self.db).cast(Interner), + environment: trait_env, + }; + let canonical = self.canonicalize(obligation.clone()); + if self.db.trait_solve(krate, canonical.value.cast(Interner)).is_some() { + self.register_obligation(obligation.goal); + let return_ty = self.normalize_projection_ty(projection); + Some((arg_tys, return_ty)) + } else { + None + } + } +} + +impl<'a> fmt::Debug for InferenceTable<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("InferenceTable").field("num_vars", &self.type_variable_table.len()).finish() + } +} + +mod resolve { + use super::InferenceTable; + use crate::{ + ConcreteConst, Const, ConstData, ConstValue, DebruijnIndex, GenericArg, InferenceVar, + Interner, Lifetime, Ty, TyVariableKind, VariableKind, + }; + use chalk_ir::{ + cast::Cast, + fold::{TypeFoldable, TypeFolder}, + Fallible, NoSolution, + }; + use hir_def::type_ref::ConstScalar; + + pub(super) struct Resolver<'a, 'b, F> { + pub(super) table: &'a mut InferenceTable<'b>, + pub(super) var_stack: &'a mut Vec<InferenceVar>, + pub(super) fallback: F, + } + impl<'a, 'b, 'i, F> TypeFolder<Interner> for Resolver<'a, 'b, F> + where + F: Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg + 'i, + { + type Error = NoSolution; + + fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner, Error = Self::Error> { + self + } + + fn interner(&self) -> Interner { + Interner + } + + fn fold_inference_ty( + &mut self, + var: InferenceVar, + kind: TyVariableKind, + outer_binder: DebruijnIndex, + ) -> Fallible<Ty> { + let var = self.table.var_unification_table.inference_var_root(var); + if self.var_stack.contains(&var) { + // recursive type + let default = self.table.fallback_value(var, kind).cast(Interner); + return Ok((self.fallback)(var, VariableKind::Ty(kind), default, outer_binder) + .assert_ty_ref(Interner) + .clone()); + } + let result = if let Some(known_ty) = self.table.var_unification_table.probe_var(var) { + // known_ty may contain other variables that are known by now + self.var_stack.push(var); + let result = + known_ty.fold_with(self, outer_binder).expect("fold failed unexpectedly"); + self.var_stack.pop(); + result.assert_ty_ref(Interner).clone() + } else { + let default = self.table.fallback_value(var, kind).cast(Interner); + (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder) + .assert_ty_ref(Interner) + .clone() + }; + Ok(result) + } + + fn fold_inference_const( + &mut self, + ty: Ty, + var: InferenceVar, + outer_binder: DebruijnIndex, + ) -> Fallible<Const> { + let var = self.table.var_unification_table.inference_var_root(var); + let default = ConstData { + ty: ty.clone(), + value: ConstValue::Concrete(ConcreteConst { interned: ConstScalar::Unknown }), + } + .intern(Interner) + .cast(Interner); + if self.var_stack.contains(&var) { + // recursive + return Ok((self.fallback)(var, VariableKind::Const(ty), default, outer_binder) + .assert_const_ref(Interner) + .clone()); + } + let result = if let Some(known_ty) = self.table.var_unification_table.probe_var(var) { + // known_ty may contain other variables that are known by now + self.var_stack.push(var); + let result = + known_ty.fold_with(self, outer_binder).expect("fold failed unexpectedly"); + self.var_stack.pop(); + result.assert_const_ref(Interner).clone() + } else { + (self.fallback)(var, VariableKind::Const(ty), default, outer_binder) + .assert_const_ref(Interner) + .clone() + }; + Ok(result) + } + + fn fold_inference_lifetime( + &mut self, + _var: InferenceVar, + _outer_binder: DebruijnIndex, + ) -> Fallible<Lifetime> { + // fall back all lifetimes to 'static -- currently we don't deal + // with any lifetimes, but we can sometimes get some lifetime + // variables through Chalk's unification, and this at least makes + // sure we don't leak them outside of inference + Ok(crate::static_lifetime()) + } + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/interner.rs new file mode 100644 index 000000000..ca76e08fd --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/interner.rs @@ -0,0 +1,432 @@ +//! Implementation of the Chalk `Interner` trait, which allows customizing the +//! representation of the various objects Chalk deals with (types, goals etc.). + +use crate::{chalk_db, tls, GenericArg}; +use base_db::salsa::InternId; +use chalk_ir::{Goal, GoalData}; +use hir_def::{ + intern::{impl_internable, InternStorage, Internable, Interned}, + type_ref::ConstScalar, + TypeAliasId, +}; +use smallvec::SmallVec; +use std::{fmt, sync::Arc}; + +#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)] +pub struct Interner; + +#[derive(PartialEq, Eq, Hash)] +pub struct InternedWrapper<T>(T); + +impl<T: fmt::Debug> fmt::Debug for InternedWrapper<T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&self.0, f) + } +} + +impl<T> std::ops::Deref for InternedWrapper<T> { + type Target = T; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl_internable!( + InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>, + InternedWrapper<SmallVec<[GenericArg; 2]>>, + InternedWrapper<chalk_ir::TyData<Interner>>, + InternedWrapper<chalk_ir::LifetimeData<Interner>>, + InternedWrapper<chalk_ir::ConstData<Interner>>, + InternedWrapper<ConstScalar>, + InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Interner>>>, + InternedWrapper<Vec<chalk_ir::ProgramClause<Interner>>>, + InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Interner>>>, + InternedWrapper<Vec<chalk_ir::Variance>>, +); + +impl chalk_ir::interner::Interner for Interner { + type InternedType = Interned<InternedWrapper<chalk_ir::TyData<Interner>>>; + type InternedLifetime = Interned<InternedWrapper<chalk_ir::LifetimeData<Self>>>; + type InternedConst = Interned<InternedWrapper<chalk_ir::ConstData<Self>>>; + type InternedConcreteConst = ConstScalar; + type InternedGenericArg = chalk_ir::GenericArgData<Self>; + type InternedGoal = Arc<GoalData<Self>>; + type InternedGoals = Vec<Goal<Self>>; + type InternedSubstitution = Interned<InternedWrapper<SmallVec<[GenericArg; 2]>>>; + type InternedProgramClause = chalk_ir::ProgramClauseData<Self>; + type InternedProgramClauses = Interned<InternedWrapper<Vec<chalk_ir::ProgramClause<Self>>>>; + type InternedQuantifiedWhereClauses = + Interned<InternedWrapper<Vec<chalk_ir::QuantifiedWhereClause<Self>>>>; + type InternedVariableKinds = Interned<InternedWrapper<Vec<chalk_ir::VariableKind<Interner>>>>; + type InternedCanonicalVarKinds = + Interned<InternedWrapper<Vec<chalk_ir::CanonicalVarKind<Self>>>>; + type InternedConstraints = Vec<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>>; + type InternedVariances = Interned<InternedWrapper<Vec<chalk_ir::Variance>>>; + type DefId = InternId; + type InternedAdtId = hir_def::AdtId; + type Identifier = TypeAliasId; + type FnAbi = (); + + fn debug_adt_id( + type_kind_id: chalk_db::AdtId, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt))) + } + + fn debug_trait_id( + type_kind_id: chalk_db::TraitId, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + tls::with_current_program(|prog| Some(prog?.debug_trait_id(type_kind_id, fmt))) + } + + fn debug_assoc_type_id( + id: chalk_db::AssocTypeId, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt))) + } + + fn debug_alias( + alias: &chalk_ir::AliasTy<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + use std::fmt::Debug; + match alias { + chalk_ir::AliasTy::Projection(projection_ty) => { + Interner::debug_projection_ty(projection_ty, fmt) + } + chalk_ir::AliasTy::Opaque(opaque_ty) => Some(opaque_ty.fmt(fmt)), + } + } + + fn debug_projection_ty( + proj: &chalk_ir::ProjectionTy<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + tls::with_current_program(|prog| Some(prog?.debug_projection_ty(proj, fmt))) + } + + fn debug_opaque_ty( + opaque_ty: &chalk_ir::OpaqueTy<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", opaque_ty.opaque_ty_id)) + } + + fn debug_opaque_ty_id( + opaque_ty_id: chalk_ir::OpaqueTyId<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "OpaqueTy#{}", opaque_ty_id.0)) + } + + fn debug_ty(ty: &chalk_ir::Ty<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", ty.data(Interner))) + } + + fn debug_lifetime( + lifetime: &chalk_ir::Lifetime<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", lifetime.data(Interner))) + } + + fn debug_generic_arg( + parameter: &GenericArg, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", parameter.data(Interner).inner_debug())) + } + + fn debug_goal(goal: &Goal<Interner>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> { + let goal_data = goal.data(Interner); + Some(write!(fmt, "{:?}", goal_data)) + } + + fn debug_goals( + goals: &chalk_ir::Goals<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", goals.debug(Interner))) + } + + fn debug_program_clause_implication( + pci: &chalk_ir::ProgramClauseImplication<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", pci.debug(Interner))) + } + + fn debug_substitution( + substitution: &chalk_ir::Substitution<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", substitution.debug(Interner))) + } + + fn debug_separator_trait_ref( + separator_trait_ref: &chalk_ir::SeparatorTraitRef<'_, Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", separator_trait_ref.debug(Interner))) + } + + fn debug_fn_def_id( + fn_def_id: chalk_ir::FnDefId<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + tls::with_current_program(|prog| Some(prog?.debug_fn_def_id(fn_def_id, fmt))) + } + fn debug_const( + constant: &chalk_ir::Const<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", constant.data(Interner))) + } + fn debug_variable_kinds( + variable_kinds: &chalk_ir::VariableKinds<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", variable_kinds.as_slice(Interner))) + } + fn debug_variable_kinds_with_angles( + variable_kinds: &chalk_ir::VariableKinds<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", variable_kinds.inner_debug(Interner))) + } + fn debug_canonical_var_kinds( + canonical_var_kinds: &chalk_ir::CanonicalVarKinds<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", canonical_var_kinds.as_slice(Interner))) + } + fn debug_program_clause( + clause: &chalk_ir::ProgramClause<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", clause.data(Interner))) + } + fn debug_program_clauses( + clauses: &chalk_ir::ProgramClauses<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", clauses.as_slice(Interner))) + } + fn debug_quantified_where_clauses( + clauses: &chalk_ir::QuantifiedWhereClauses<Self>, + fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + Some(write!(fmt, "{:?}", clauses.as_slice(Interner))) + } + + fn intern_ty(self, kind: chalk_ir::TyKind<Self>) -> Self::InternedType { + let flags = kind.compute_flags(self); + Interned::new(InternedWrapper(chalk_ir::TyData { kind, flags })) + } + + fn ty_data<'a>(self, ty: &'a Self::InternedType) -> &'a chalk_ir::TyData<Self> { + &ty.0 + } + + fn intern_lifetime(self, lifetime: chalk_ir::LifetimeData<Self>) -> Self::InternedLifetime { + Interned::new(InternedWrapper(lifetime)) + } + + fn lifetime_data<'a>( + self, + lifetime: &'a Self::InternedLifetime, + ) -> &'a chalk_ir::LifetimeData<Self> { + &lifetime.0 + } + + fn intern_const(self, constant: chalk_ir::ConstData<Self>) -> Self::InternedConst { + Interned::new(InternedWrapper(constant)) + } + + fn const_data<'a>(self, constant: &'a Self::InternedConst) -> &'a chalk_ir::ConstData<Self> { + &constant.0 + } + + fn const_eq( + self, + _ty: &Self::InternedType, + c1: &Self::InternedConcreteConst, + c2: &Self::InternedConcreteConst, + ) -> bool { + (c1 == &ConstScalar::Unknown) || (c2 == &ConstScalar::Unknown) || (c1 == c2) + } + + fn intern_generic_arg( + self, + parameter: chalk_ir::GenericArgData<Self>, + ) -> Self::InternedGenericArg { + parameter + } + + fn generic_arg_data<'a>( + self, + parameter: &'a Self::InternedGenericArg, + ) -> &'a chalk_ir::GenericArgData<Self> { + parameter + } + + fn intern_goal(self, goal: GoalData<Self>) -> Self::InternedGoal { + Arc::new(goal) + } + + fn intern_goals<E>( + self, + data: impl IntoIterator<Item = Result<Goal<Self>, E>>, + ) -> Result<Self::InternedGoals, E> { + data.into_iter().collect() + } + + fn goal_data<'a>(self, goal: &'a Self::InternedGoal) -> &'a GoalData<Self> { + goal + } + + fn goals_data<'a>(self, goals: &'a Self::InternedGoals) -> &'a [Goal<Interner>] { + goals + } + + fn intern_substitution<E>( + self, + data: impl IntoIterator<Item = Result<GenericArg, E>>, + ) -> Result<Self::InternedSubstitution, E> { + Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) + } + + fn substitution_data<'a>( + self, + substitution: &'a Self::InternedSubstitution, + ) -> &'a [GenericArg] { + &substitution.as_ref().0 + } + + fn intern_program_clause( + self, + data: chalk_ir::ProgramClauseData<Self>, + ) -> Self::InternedProgramClause { + data + } + + fn program_clause_data<'a>( + self, + clause: &'a Self::InternedProgramClause, + ) -> &'a chalk_ir::ProgramClauseData<Self> { + clause + } + + fn intern_program_clauses<E>( + self, + data: impl IntoIterator<Item = Result<chalk_ir::ProgramClause<Self>, E>>, + ) -> Result<Self::InternedProgramClauses, E> { + Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) + } + + fn program_clauses_data<'a>( + self, + clauses: &'a Self::InternedProgramClauses, + ) -> &'a [chalk_ir::ProgramClause<Self>] { + clauses + } + + fn intern_quantified_where_clauses<E>( + self, + data: impl IntoIterator<Item = Result<chalk_ir::QuantifiedWhereClause<Self>, E>>, + ) -> Result<Self::InternedQuantifiedWhereClauses, E> { + Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) + } + + fn quantified_where_clauses_data<'a>( + self, + clauses: &'a Self::InternedQuantifiedWhereClauses, + ) -> &'a [chalk_ir::QuantifiedWhereClause<Self>] { + clauses + } + + fn intern_generic_arg_kinds<E>( + self, + data: impl IntoIterator<Item = Result<chalk_ir::VariableKind<Self>, E>>, + ) -> Result<Self::InternedVariableKinds, E> { + Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) + } + + fn variable_kinds_data<'a>( + self, + parameter_kinds: &'a Self::InternedVariableKinds, + ) -> &'a [chalk_ir::VariableKind<Self>] { + ¶meter_kinds.as_ref().0 + } + + fn intern_canonical_var_kinds<E>( + self, + data: impl IntoIterator<Item = Result<chalk_ir::CanonicalVarKind<Self>, E>>, + ) -> Result<Self::InternedCanonicalVarKinds, E> { + Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) + } + + fn canonical_var_kinds_data<'a>( + self, + canonical_var_kinds: &'a Self::InternedCanonicalVarKinds, + ) -> &'a [chalk_ir::CanonicalVarKind<Self>] { + canonical_var_kinds + } + + fn intern_constraints<E>( + self, + data: impl IntoIterator<Item = Result<chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>, E>>, + ) -> Result<Self::InternedConstraints, E> { + data.into_iter().collect() + } + + fn constraints_data<'a>( + self, + constraints: &'a Self::InternedConstraints, + ) -> &'a [chalk_ir::InEnvironment<chalk_ir::Constraint<Self>>] { + constraints + } + fn debug_closure_id( + _fn_def_id: chalk_ir::ClosureId<Self>, + _fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + None + } + fn debug_constraints( + _clauses: &chalk_ir::Constraints<Self>, + _fmt: &mut fmt::Formatter<'_>, + ) -> Option<fmt::Result> { + None + } + + fn intern_variances<E>( + self, + data: impl IntoIterator<Item = Result<chalk_ir::Variance, E>>, + ) -> Result<Self::InternedVariances, E> { + Ok(Interned::new(InternedWrapper(data.into_iter().collect::<Result<_, _>>()?))) + } + + fn variances_data<'a>( + self, + variances: &'a Self::InternedVariances, + ) -> &'a [chalk_ir::Variance] { + variances + } +} + +impl chalk_ir::interner::HasInterner for Interner { + type Interner = Self; +} + +#[macro_export] +macro_rules! has_interner { + ($t:ty) => { + impl HasInterner for $t { + type Interner = crate::Interner; + } + }; +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs new file mode 100644 index 000000000..5a5d610e3 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs @@ -0,0 +1,525 @@ +//! The type system. We currently use this to infer types for completion, hover +//! information and various assists. + +#![warn(rust_2018_idioms, unused_lifetimes, semicolon_in_expressions_from_macros)] + +#[allow(unused)] +macro_rules! eprintln { + ($($tt:tt)*) => { stdx::eprintln!($($tt)*) }; +} + +mod autoderef; +mod builder; +mod chalk_db; +mod chalk_ext; +pub mod consteval; +mod infer; +mod interner; +mod lower; +mod mapping; +mod tls; +mod utils; +mod walk; +pub mod db; +pub mod diagnostics; +pub mod display; +pub mod method_resolution; +pub mod primitive; +pub mod traits; + +#[cfg(test)] +mod tests; +#[cfg(test)] +mod test_db; + +use std::sync::Arc; + +use chalk_ir::{ + fold::{Shift, TypeFoldable}, + interner::HasInterner, + NoSolution, +}; +use hir_def::{expr::ExprId, type_ref::Rawness, TypeOrConstParamId}; +use itertools::Either; +use utils::Generics; + +use crate::{consteval::unknown_const, db::HirDatabase, utils::generics}; + +pub use autoderef::autoderef; +pub use builder::{ParamKind, TyBuilder}; +pub use chalk_ext::*; +pub use infer::{ + could_coerce, could_unify, Adjust, Adjustment, AutoBorrow, BindingMode, InferenceDiagnostic, + InferenceResult, +}; +pub use interner::Interner; +pub use lower::{ + associated_type_shorthand_candidates, CallableDefId, ImplTraitLoweringMode, TyDefId, + TyLoweringContext, ValueTyDefId, +}; +pub use mapping::{ + from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx, + lt_from_placeholder_idx, to_assoc_type_id, to_chalk_trait_id, to_foreign_def_id, + to_placeholder_idx, +}; +pub use traits::TraitEnvironment; +pub use utils::{all_super_traits, is_fn_unsafe_to_call}; +pub use walk::TypeWalk; + +pub use chalk_ir::{ + cast::Cast, AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind, +}; + +pub type ForeignDefId = chalk_ir::ForeignDefId<Interner>; +pub type AssocTypeId = chalk_ir::AssocTypeId<Interner>; +pub type FnDefId = chalk_ir::FnDefId<Interner>; +pub type ClosureId = chalk_ir::ClosureId<Interner>; +pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>; +pub type PlaceholderIndex = chalk_ir::PlaceholderIndex; + +pub type VariableKind = chalk_ir::VariableKind<Interner>; +pub type VariableKinds = chalk_ir::VariableKinds<Interner>; +pub type CanonicalVarKinds = chalk_ir::CanonicalVarKinds<Interner>; +pub type Binders<T> = chalk_ir::Binders<T>; +pub type Substitution = chalk_ir::Substitution<Interner>; +pub type GenericArg = chalk_ir::GenericArg<Interner>; +pub type GenericArgData = chalk_ir::GenericArgData<Interner>; + +pub type Ty = chalk_ir::Ty<Interner>; +pub type TyKind = chalk_ir::TyKind<Interner>; +pub type DynTy = chalk_ir::DynTy<Interner>; +pub type FnPointer = chalk_ir::FnPointer<Interner>; +// pub type FnSubst = chalk_ir::FnSubst<Interner>; +pub use chalk_ir::FnSubst; +pub type ProjectionTy = chalk_ir::ProjectionTy<Interner>; +pub type AliasTy = chalk_ir::AliasTy<Interner>; +pub type OpaqueTy = chalk_ir::OpaqueTy<Interner>; +pub type InferenceVar = chalk_ir::InferenceVar; + +pub type Lifetime = chalk_ir::Lifetime<Interner>; +pub type LifetimeData = chalk_ir::LifetimeData<Interner>; +pub type LifetimeOutlives = chalk_ir::LifetimeOutlives<Interner>; + +pub type Const = chalk_ir::Const<Interner>; +pub type ConstData = chalk_ir::ConstData<Interner>; +pub type ConstValue = chalk_ir::ConstValue<Interner>; +pub type ConcreteConst = chalk_ir::ConcreteConst<Interner>; + +pub type ChalkTraitId = chalk_ir::TraitId<Interner>; +pub type TraitRef = chalk_ir::TraitRef<Interner>; +pub type QuantifiedWhereClause = Binders<WhereClause>; +pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>; +pub type Canonical<T> = chalk_ir::Canonical<T>; + +pub type FnSig = chalk_ir::FnSig<Interner>; + +pub type InEnvironment<T> = chalk_ir::InEnvironment<T>; +pub type Environment = chalk_ir::Environment<Interner>; +pub type DomainGoal = chalk_ir::DomainGoal<Interner>; +pub type Goal = chalk_ir::Goal<Interner>; +pub type AliasEq = chalk_ir::AliasEq<Interner>; +pub type Solution = chalk_solve::Solution<Interner>; +pub type ConstrainedSubst = chalk_ir::ConstrainedSubst<Interner>; +pub type Guidance = chalk_solve::Guidance<Interner>; +pub type WhereClause = chalk_ir::WhereClause<Interner>; + +// FIXME: get rid of this +pub fn subst_prefix(s: &Substitution, n: usize) -> Substitution { + Substitution::from_iter( + Interner, + s.as_slice(Interner)[..std::cmp::min(s.len(Interner), n)].iter().cloned(), + ) +} + +/// Return an index of a parameter in the generic type parameter list by it's id. +pub fn param_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> Option<usize> { + generics(db.upcast(), id.parent).param_idx(id) +} + +pub(crate) fn wrap_empty_binders<T>(value: T) -> Binders<T> +where + T: TypeFoldable<Interner> + HasInterner<Interner = Interner>, +{ + Binders::empty(Interner, value.shifted_in_from(Interner, DebruijnIndex::ONE)) +} + +pub(crate) fn make_type_and_const_binders<T: HasInterner<Interner = Interner>>( + which_is_const: impl Iterator<Item = Option<Ty>>, + value: T, +) -> Binders<T> { + Binders::new( + VariableKinds::from_iter( + Interner, + which_is_const.map(|x| { + if let Some(ty) = x { + chalk_ir::VariableKind::Const(ty) + } else { + chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General) + } + }), + ), + value, + ) +} + +pub(crate) fn make_single_type_binders<T: HasInterner<Interner = Interner>>( + value: T, +) -> Binders<T> { + Binders::new( + VariableKinds::from_iter( + Interner, + std::iter::once(chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)), + ), + value, + ) +} + +pub(crate) fn make_binders_with_count<T: HasInterner<Interner = Interner>>( + db: &dyn HirDatabase, + count: usize, + generics: &Generics, + value: T, +) -> Binders<T> { + let it = generics.iter_id().take(count).map(|id| match id { + Either::Left(_) => None, + Either::Right(id) => Some(db.const_param_ty(id)), + }); + crate::make_type_and_const_binders(it, value) +} + +pub(crate) fn make_binders<T: HasInterner<Interner = Interner>>( + db: &dyn HirDatabase, + generics: &Generics, + value: T, +) -> Binders<T> { + make_binders_with_count(db, usize::MAX, generics, value) +} + +// FIXME: get rid of this +pub fn make_canonical<T: HasInterner<Interner = Interner>>( + value: T, + kinds: impl IntoIterator<Item = TyVariableKind>, +) -> Canonical<T> { + let kinds = kinds.into_iter().map(|tk| { + chalk_ir::CanonicalVarKind::new( + chalk_ir::VariableKind::Ty(tk), + chalk_ir::UniverseIndex::ROOT, + ) + }); + Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(Interner, kinds) } +} + +// FIXME: get rid of this, just replace it by FnPointer +/// A function signature as seen by type inference: Several parameter types and +/// one return type. +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct CallableSig { + params_and_return: Arc<[Ty]>, + is_varargs: bool, +} + +has_interner!(CallableSig); + +/// A polymorphic function signature. +pub type PolyFnSig = Binders<CallableSig>; + +impl CallableSig { + pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty, is_varargs: bool) -> CallableSig { + params.push(ret); + CallableSig { params_and_return: params.into(), is_varargs } + } + + pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig { + CallableSig { + // FIXME: what to do about lifetime params? -> return PolyFnSig + params_and_return: fn_ptr + .substitution + .clone() + .shifted_out_to(Interner, DebruijnIndex::ONE) + .expect("unexpected lifetime vars in fn ptr") + .0 + .as_slice(Interner) + .iter() + .map(|arg| arg.assert_ty_ref(Interner).clone()) + .collect(), + is_varargs: fn_ptr.sig.variadic, + } + } + + pub fn to_fn_ptr(&self) -> FnPointer { + FnPointer { + num_binders: 0, + sig: FnSig { abi: (), safety: Safety::Safe, variadic: self.is_varargs }, + substitution: FnSubst(Substitution::from_iter( + Interner, + self.params_and_return.iter().cloned(), + )), + } + } + + pub fn params(&self) -> &[Ty] { + &self.params_and_return[0..self.params_and_return.len() - 1] + } + + pub fn ret(&self) -> &Ty { + &self.params_and_return[self.params_and_return.len() - 1] + } +} + +impl TypeFoldable<Interner> for CallableSig { + fn fold_with<E>( + self, + folder: &mut dyn chalk_ir::fold::TypeFolder<Interner, Error = E>, + outer_binder: DebruijnIndex, + ) -> Result<Self, E> { + let vec = self.params_and_return.to_vec(); + let folded = vec.fold_with(folder, outer_binder)?; + Ok(CallableSig { params_and_return: folded.into(), is_varargs: self.is_varargs }) + } +} + +#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)] +pub enum ImplTraitId { + ReturnTypeImplTrait(hir_def::FunctionId, u16), + AsyncBlockTypeImplTrait(hir_def::DefWithBodyId, ExprId), +} + +#[derive(Clone, PartialEq, Eq, Debug, Hash)] +pub struct ReturnTypeImplTraits { + pub(crate) impl_traits: Vec<ReturnTypeImplTrait>, +} + +has_interner!(ReturnTypeImplTraits); + +#[derive(Clone, PartialEq, Eq, Debug, Hash)] +pub(crate) struct ReturnTypeImplTrait { + pub(crate) bounds: Binders<Vec<QuantifiedWhereClause>>, +} + +pub fn static_lifetime() -> Lifetime { + LifetimeData::Static.intern(Interner) +} + +pub(crate) fn fold_free_vars<T: HasInterner<Interner = Interner> + TypeFoldable<Interner>>( + t: T, + for_ty: impl FnMut(BoundVar, DebruijnIndex) -> Ty, + for_const: impl FnMut(Ty, BoundVar, DebruijnIndex) -> Const, +) -> T { + use chalk_ir::{fold::TypeFolder, Fallible}; + struct FreeVarFolder<F1, F2>(F1, F2); + impl< + 'i, + F1: FnMut(BoundVar, DebruijnIndex) -> Ty + 'i, + F2: FnMut(Ty, BoundVar, DebruijnIndex) -> Const + 'i, + > TypeFolder<Interner> for FreeVarFolder<F1, F2> + { + type Error = NoSolution; + + fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner, Error = Self::Error> { + self + } + + fn interner(&self) -> Interner { + Interner + } + + fn fold_free_var_ty( + &mut self, + bound_var: BoundVar, + outer_binder: DebruijnIndex, + ) -> Fallible<Ty> { + Ok(self.0(bound_var, outer_binder)) + } + + fn fold_free_var_const( + &mut self, + ty: Ty, + bound_var: BoundVar, + outer_binder: DebruijnIndex, + ) -> Fallible<Const> { + Ok(self.1(ty, bound_var, outer_binder)) + } + } + t.fold_with(&mut FreeVarFolder(for_ty, for_const), DebruijnIndex::INNERMOST) + .expect("fold failed unexpectedly") +} + +pub(crate) fn fold_tys<T: HasInterner<Interner = Interner> + TypeFoldable<Interner>>( + t: T, + mut for_ty: impl FnMut(Ty, DebruijnIndex) -> Ty, + binders: DebruijnIndex, +) -> T { + fold_tys_and_consts( + t, + |x, d| match x { + Either::Left(x) => Either::Left(for_ty(x, d)), + Either::Right(x) => Either::Right(x), + }, + binders, + ) +} + +pub(crate) fn fold_tys_and_consts<T: HasInterner<Interner = Interner> + TypeFoldable<Interner>>( + t: T, + f: impl FnMut(Either<Ty, Const>, DebruijnIndex) -> Either<Ty, Const>, + binders: DebruijnIndex, +) -> T { + use chalk_ir::{ + fold::{TypeFolder, TypeSuperFoldable}, + Fallible, + }; + struct TyFolder<F>(F); + impl<'i, F: FnMut(Either<Ty, Const>, DebruijnIndex) -> Either<Ty, Const> + 'i> + TypeFolder<Interner> for TyFolder<F> + { + type Error = NoSolution; + + fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner, Error = Self::Error> { + self + } + + fn interner(&self) -> Interner { + Interner + } + + fn fold_ty(&mut self, ty: Ty, outer_binder: DebruijnIndex) -> Fallible<Ty> { + let ty = ty.super_fold_with(self.as_dyn(), outer_binder)?; + Ok(self.0(Either::Left(ty), outer_binder).left().unwrap()) + } + + fn fold_const(&mut self, c: Const, outer_binder: DebruijnIndex) -> Fallible<Const> { + Ok(self.0(Either::Right(c), outer_binder).right().unwrap()) + } + } + t.fold_with(&mut TyFolder(f), binders).expect("fold failed unexpectedly") +} + +/// 'Canonicalizes' the `t` by replacing any errors with new variables. Also +/// ensures there are no unbound variables or inference variables anywhere in +/// the `t`. +pub fn replace_errors_with_variables<T>(t: &T) -> Canonical<T> +where + T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + Clone, + T: HasInterner<Interner = Interner>, +{ + use chalk_ir::{ + fold::{TypeFolder, TypeSuperFoldable}, + Fallible, + }; + struct ErrorReplacer { + vars: usize, + } + impl TypeFolder<Interner> for ErrorReplacer { + type Error = NoSolution; + + fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner, Error = Self::Error> { + self + } + + fn interner(&self) -> Interner { + Interner + } + + fn fold_ty(&mut self, ty: Ty, outer_binder: DebruijnIndex) -> Fallible<Ty> { + if let TyKind::Error = ty.kind(Interner) { + let index = self.vars; + self.vars += 1; + Ok(TyKind::BoundVar(BoundVar::new(outer_binder, index)).intern(Interner)) + } else { + let ty = ty.super_fold_with(self.as_dyn(), outer_binder)?; + Ok(ty) + } + } + + fn fold_inference_ty( + &mut self, + _var: InferenceVar, + _kind: TyVariableKind, + _outer_binder: DebruijnIndex, + ) -> Fallible<Ty> { + if cfg!(debug_assertions) { + // we don't want to just panic here, because then the error message + // won't contain the whole thing, which would not be very helpful + Err(NoSolution) + } else { + Ok(TyKind::Error.intern(Interner)) + } + } + + fn fold_free_var_ty( + &mut self, + _bound_var: BoundVar, + _outer_binder: DebruijnIndex, + ) -> Fallible<Ty> { + if cfg!(debug_assertions) { + // we don't want to just panic here, because then the error message + // won't contain the whole thing, which would not be very helpful + Err(NoSolution) + } else { + Ok(TyKind::Error.intern(Interner)) + } + } + + fn fold_inference_const( + &mut self, + ty: Ty, + _var: InferenceVar, + _outer_binder: DebruijnIndex, + ) -> Fallible<Const> { + if cfg!(debug_assertions) { + Err(NoSolution) + } else { + Ok(unknown_const(ty)) + } + } + + fn fold_free_var_const( + &mut self, + ty: Ty, + _bound_var: BoundVar, + _outer_binder: DebruijnIndex, + ) -> Fallible<Const> { + if cfg!(debug_assertions) { + Err(NoSolution) + } else { + Ok(unknown_const(ty)) + } + } + + fn fold_inference_lifetime( + &mut self, + _var: InferenceVar, + _outer_binder: DebruijnIndex, + ) -> Fallible<Lifetime> { + if cfg!(debug_assertions) { + Err(NoSolution) + } else { + Ok(static_lifetime()) + } + } + + fn fold_free_var_lifetime( + &mut self, + _bound_var: BoundVar, + _outer_binder: DebruijnIndex, + ) -> Fallible<Lifetime> { + if cfg!(debug_assertions) { + Err(NoSolution) + } else { + Ok(static_lifetime()) + } + } + } + let mut error_replacer = ErrorReplacer { vars: 0 }; + let value = match t.clone().fold_with(&mut error_replacer, DebruijnIndex::INNERMOST) { + Ok(t) => t, + Err(_) => panic!("Encountered unbound or inference vars in {:?}", t), + }; + let kinds = (0..error_replacer.vars).map(|_| { + chalk_ir::CanonicalVarKind::new( + chalk_ir::VariableKind::Ty(TyVariableKind::General), + chalk_ir::UniverseIndex::ROOT, + ) + }); + Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(Interner, kinds) } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs new file mode 100644 index 000000000..3ed9c941f --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs @@ -0,0 +1,1778 @@ +//! Methods for lowering the HIR to types. There are two main cases here: +//! +//! - Lowering a type reference like `&usize` or `Option<foo::bar::Baz>` to a +//! type: The entry point for this is `Ty::from_hir`. +//! - Building the type for an item: This happens through the `type_for_def` query. +//! +//! This usually involves resolving names, collecting generic arguments etc. +use std::{ + cell::{Cell, RefCell}, + iter, + sync::Arc, +}; + +use base_db::CrateId; +use chalk_ir::{ + cast::Cast, fold::Shift, fold::TypeFoldable, interner::HasInterner, Mutability, Safety, +}; + +use hir_def::{ + adt::StructKind, + body::{Expander, LowerCtx}, + builtin_type::BuiltinType, + generics::{ + TypeOrConstParamData, TypeParamProvenance, WherePredicate, WherePredicateTypeTarget, + }, + intern::Interned, + lang_item::lang_attr, + path::{GenericArg, ModPath, Path, PathKind, PathSegment, PathSegments}, + resolver::{HasResolver, Resolver, TypeNs}, + type_ref::{ + ConstScalarOrPath, TraitBoundModifier, TraitRef as HirTraitRef, TypeBound, TypeRef, + }, + AdtId, AssocItemId, ConstId, ConstParamId, EnumId, EnumVariantId, FunctionId, GenericDefId, + HasModule, ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId, StructId, TraitId, + TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId, VariantId, +}; +use hir_expand::{name::Name, ExpandResult}; +use itertools::Either; +use la_arena::ArenaMap; +use rustc_hash::FxHashSet; +use smallvec::SmallVec; +use stdx::{impl_from, never}; +use syntax::{ast, SmolStr}; + +use crate::{ + all_super_traits, + consteval::{intern_const_scalar, path_to_const, unknown_const, unknown_const_as_generic}, + db::HirDatabase, + make_binders, + mapping::ToChalk, + static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx, + utils::Generics, + utils::{all_super_trait_refs, associated_type_by_name_including_super_traits, generics}, + AliasEq, AliasTy, Binders, BoundVar, CallableSig, Const, DebruijnIndex, DynTy, FnPointer, + FnSig, FnSubst, GenericArgData, ImplTraitId, Interner, ParamKind, PolyFnSig, ProjectionTy, + QuantifiedWhereClause, QuantifiedWhereClauses, ReturnTypeImplTrait, ReturnTypeImplTraits, + Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause, +}; + +#[derive(Debug)] +pub struct TyLoweringContext<'a> { + pub db: &'a dyn HirDatabase, + pub resolver: &'a Resolver, + in_binders: DebruijnIndex, + /// Note: Conceptually, it's thinkable that we could be in a location where + /// some type params should be represented as placeholders, and others + /// should be converted to variables. I think in practice, this isn't + /// possible currently, so this should be fine for now. + pub type_param_mode: ParamLoweringMode, + pub impl_trait_mode: ImplTraitLoweringMode, + impl_trait_counter: Cell<u16>, + /// When turning `impl Trait` into opaque types, we have to collect the + /// bounds at the same time to get the IDs correct (without becoming too + /// complicated). I don't like using interior mutability (as for the + /// counter), but I've tried and failed to make the lifetimes work for + /// passing around a `&mut TyLoweringContext`. The core problem is that + /// we're grouping the mutable data (the counter and this field) together + /// with the immutable context (the references to the DB and resolver). + /// Splitting this up would be a possible fix. + opaque_type_data: RefCell<Vec<ReturnTypeImplTrait>>, + expander: RefCell<Option<Expander>>, + /// Tracks types with explicit `?Sized` bounds. + pub(crate) unsized_types: RefCell<FxHashSet<Ty>>, +} + +impl<'a> TyLoweringContext<'a> { + pub fn new(db: &'a dyn HirDatabase, resolver: &'a Resolver) -> Self { + let impl_trait_counter = Cell::new(0); + let impl_trait_mode = ImplTraitLoweringMode::Disallowed; + let type_param_mode = ParamLoweringMode::Placeholder; + let in_binders = DebruijnIndex::INNERMOST; + let opaque_type_data = RefCell::new(Vec::new()); + Self { + db, + resolver, + in_binders, + impl_trait_mode, + impl_trait_counter, + type_param_mode, + opaque_type_data, + expander: RefCell::new(None), + unsized_types: RefCell::default(), + } + } + + pub fn with_debruijn<T>( + &self, + debruijn: DebruijnIndex, + f: impl FnOnce(&TyLoweringContext<'_>) -> T, + ) -> T { + let opaque_ty_data_vec = self.opaque_type_data.take(); + let expander = self.expander.take(); + let unsized_types = self.unsized_types.take(); + let new_ctx = Self { + in_binders: debruijn, + impl_trait_counter: Cell::new(self.impl_trait_counter.get()), + opaque_type_data: RefCell::new(opaque_ty_data_vec), + expander: RefCell::new(expander), + unsized_types: RefCell::new(unsized_types), + ..*self + }; + let result = f(&new_ctx); + self.impl_trait_counter.set(new_ctx.impl_trait_counter.get()); + self.opaque_type_data.replace(new_ctx.opaque_type_data.into_inner()); + self.expander.replace(new_ctx.expander.into_inner()); + self.unsized_types.replace(new_ctx.unsized_types.into_inner()); + result + } + + pub fn with_shifted_in<T>( + &self, + debruijn: DebruijnIndex, + f: impl FnOnce(&TyLoweringContext<'_>) -> T, + ) -> T { + self.with_debruijn(self.in_binders.shifted_in_from(debruijn), f) + } + + pub fn with_impl_trait_mode(self, impl_trait_mode: ImplTraitLoweringMode) -> Self { + Self { impl_trait_mode, ..self } + } + + pub fn with_type_param_mode(self, type_param_mode: ParamLoweringMode) -> Self { + Self { type_param_mode, ..self } + } +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum ImplTraitLoweringMode { + /// `impl Trait` gets lowered into an opaque type that doesn't unify with + /// anything except itself. This is used in places where values flow 'out', + /// i.e. for arguments of the function we're currently checking, and return + /// types of functions we're calling. + Opaque, + /// `impl Trait` gets lowered into a type variable. Used for argument + /// position impl Trait when inside the respective function, since it allows + /// us to support that without Chalk. + Param, + /// `impl Trait` gets lowered into a variable that can unify with some + /// type. This is used in places where values flow 'in', i.e. for arguments + /// of functions we're calling, and the return type of the function we're + /// currently checking. + Variable, + /// `impl Trait` is disallowed and will be an error. + Disallowed, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum ParamLoweringMode { + Placeholder, + Variable, +} + +impl<'a> TyLoweringContext<'a> { + pub fn lower_ty(&self, type_ref: &TypeRef) -> Ty { + self.lower_ty_ext(type_ref).0 + } + + fn generics(&self) -> Generics { + generics( + self.db.upcast(), + self.resolver + .generic_def() + .expect("there should be generics if there's a generic param"), + ) + } + + pub fn lower_ty_ext(&self, type_ref: &TypeRef) -> (Ty, Option<TypeNs>) { + let mut res = None; + let ty = match type_ref { + TypeRef::Never => TyKind::Never.intern(Interner), + TypeRef::Tuple(inner) => { + let inner_tys = inner.iter().map(|tr| self.lower_ty(tr)); + TyKind::Tuple(inner_tys.len(), Substitution::from_iter(Interner, inner_tys)) + .intern(Interner) + } + TypeRef::Path(path) => { + let (ty, res_) = self.lower_path(path); + res = res_; + ty + } + TypeRef::RawPtr(inner, mutability) => { + let inner_ty = self.lower_ty(inner); + TyKind::Raw(lower_to_chalk_mutability(*mutability), inner_ty).intern(Interner) + } + TypeRef::Array(inner, len) => { + let inner_ty = self.lower_ty(inner); + let const_len = const_or_path_to_chalk( + self.db, + self.resolver, + TyBuilder::usize(), + len, + self.type_param_mode, + || self.generics(), + self.in_binders, + ); + + TyKind::Array(inner_ty, const_len).intern(Interner) + } + TypeRef::Slice(inner) => { + let inner_ty = self.lower_ty(inner); + TyKind::Slice(inner_ty).intern(Interner) + } + TypeRef::Reference(inner, _, mutability) => { + let inner_ty = self.lower_ty(inner); + let lifetime = static_lifetime(); + TyKind::Ref(lower_to_chalk_mutability(*mutability), lifetime, inner_ty) + .intern(Interner) + } + TypeRef::Placeholder => TyKind::Error.intern(Interner), + TypeRef::Fn(params, is_varargs) => { + let substs = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { + Substitution::from_iter(Interner, params.iter().map(|(_, tr)| ctx.lower_ty(tr))) + }); + TyKind::Function(FnPointer { + num_binders: 0, // FIXME lower `for<'a> fn()` correctly + sig: FnSig { abi: (), safety: Safety::Safe, variadic: *is_varargs }, + substitution: FnSubst(substs), + }) + .intern(Interner) + } + TypeRef::DynTrait(bounds) => { + let self_ty = + TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(Interner); + let bounds = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { + QuantifiedWhereClauses::from_iter( + Interner, + bounds.iter().flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false)), + ) + }); + let bounds = crate::make_single_type_binders(bounds); + TyKind::Dyn(DynTy { bounds, lifetime: static_lifetime() }).intern(Interner) + } + TypeRef::ImplTrait(bounds) => { + match self.impl_trait_mode { + ImplTraitLoweringMode::Opaque => { + let idx = self.impl_trait_counter.get(); + self.impl_trait_counter.set(idx + 1); + let func = match self.resolver.generic_def() { + Some(GenericDefId::FunctionId(f)) => f, + _ => panic!("opaque impl trait lowering in non-function"), + }; + + assert!(idx as usize == self.opaque_type_data.borrow().len()); + // this dance is to make sure the data is in the right + // place even if we encounter more opaque types while + // lowering the bounds + self.opaque_type_data.borrow_mut().push(ReturnTypeImplTrait { + bounds: crate::make_single_type_binders(Vec::new()), + }); + // We don't want to lower the bounds inside the binders + // we're currently in, because they don't end up inside + // those binders. E.g. when we have `impl Trait<impl + // OtherTrait<T>>`, the `impl OtherTrait<T>` can't refer + // to the self parameter from `impl Trait`, and the + // bounds aren't actually stored nested within each + // other, but separately. So if the `T` refers to a type + // parameter of the outer function, it's just one binder + // away instead of two. + let actual_opaque_type_data = self + .with_debruijn(DebruijnIndex::INNERMOST, |ctx| { + ctx.lower_impl_trait(bounds, func) + }); + self.opaque_type_data.borrow_mut()[idx as usize] = actual_opaque_type_data; + + let impl_trait_id = ImplTraitId::ReturnTypeImplTrait(func, idx); + let opaque_ty_id = self.db.intern_impl_trait_id(impl_trait_id).into(); + let generics = generics(self.db.upcast(), func.into()); + let parameters = generics.bound_vars_subst(self.db, self.in_binders); + TyKind::OpaqueType(opaque_ty_id, parameters).intern(Interner) + } + ImplTraitLoweringMode::Param => { + let idx = self.impl_trait_counter.get(); + // FIXME we're probably doing something wrong here + self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); + if let Some(def) = self.resolver.generic_def() { + let generics = generics(self.db.upcast(), def); + let param = generics + .iter() + .filter(|(_, data)| { + matches!( + data, + TypeOrConstParamData::TypeParamData(data) + if data.provenance == TypeParamProvenance::ArgumentImplTrait + ) + }) + .nth(idx as usize) + .map_or(TyKind::Error, |(id, _)| { + TyKind::Placeholder(to_placeholder_idx(self.db, id)) + }); + param.intern(Interner) + } else { + TyKind::Error.intern(Interner) + } + } + ImplTraitLoweringMode::Variable => { + let idx = self.impl_trait_counter.get(); + // FIXME we're probably doing something wrong here + self.impl_trait_counter.set(idx + count_impl_traits(type_ref) as u16); + let ( + parent_params, + self_params, + list_params, + const_params, + _impl_trait_params, + ) = if let Some(def) = self.resolver.generic_def() { + let generics = generics(self.db.upcast(), def); + generics.provenance_split() + } else { + (0, 0, 0, 0, 0) + }; + TyKind::BoundVar(BoundVar::new( + self.in_binders, + idx as usize + parent_params + self_params + list_params + const_params, + )) + .intern(Interner) + } + ImplTraitLoweringMode::Disallowed => { + // FIXME: report error + TyKind::Error.intern(Interner) + } + } + } + TypeRef::Macro(macro_call) => { + let (expander, recursion_start) = { + let mut expander = self.expander.borrow_mut(); + if expander.is_some() { + (Some(expander), false) + } else { + *expander = Some(Expander::new( + self.db.upcast(), + macro_call.file_id, + self.resolver.module(), + )); + (Some(expander), true) + } + }; + let ty = if let Some(mut expander) = expander { + let expander_mut = expander.as_mut().unwrap(); + let macro_call = macro_call.to_node(self.db.upcast()); + match expander_mut.enter_expand::<ast::Type>(self.db.upcast(), macro_call) { + Ok(ExpandResult { value: Some((mark, expanded)), .. }) => { + let ctx = + LowerCtx::new(self.db.upcast(), expander_mut.current_file_id()); + let type_ref = TypeRef::from_ast(&ctx, expanded); + + drop(expander); + let ty = self.lower_ty(&type_ref); + + self.expander + .borrow_mut() + .as_mut() + .unwrap() + .exit(self.db.upcast(), mark); + Some(ty) + } + _ => None, + } + } else { + None + }; + if recursion_start { + *self.expander.borrow_mut() = None; + } + ty.unwrap_or_else(|| TyKind::Error.intern(Interner)) + } + TypeRef::Error => TyKind::Error.intern(Interner), + }; + (ty, res) + } + + /// This is only for `generic_predicates_for_param`, where we can't just + /// lower the self types of the predicates since that could lead to cycles. + /// So we just check here if the `type_ref` resolves to a generic param, and which. + fn lower_ty_only_param(&self, type_ref: &TypeRef) -> Option<TypeOrConstParamId> { + let path = match type_ref { + TypeRef::Path(path) => path, + _ => return None, + }; + if path.type_anchor().is_some() { + return None; + } + if path.segments().len() > 1 { + return None; + } + let resolution = + match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { + Some((it, None)) => it, + _ => return None, + }; + match resolution { + TypeNs::GenericParam(param_id) => Some(param_id.into()), + _ => None, + } + } + + pub(crate) fn lower_ty_relative_path( + &self, + ty: Ty, + // We need the original resolution to lower `Self::AssocTy` correctly + res: Option<TypeNs>, + remaining_segments: PathSegments<'_>, + ) -> (Ty, Option<TypeNs>) { + match remaining_segments.len() { + 0 => (ty, res), + 1 => { + // resolve unselected assoc types + let segment = remaining_segments.first().unwrap(); + (self.select_associated_type(res, segment), None) + } + _ => { + // FIXME report error (ambiguous associated type) + (TyKind::Error.intern(Interner), None) + } + } + } + + pub(crate) fn lower_partly_resolved_path( + &self, + resolution: TypeNs, + resolved_segment: PathSegment<'_>, + remaining_segments: PathSegments<'_>, + infer_args: bool, + ) -> (Ty, Option<TypeNs>) { + let ty = match resolution { + TypeNs::TraitId(trait_) => { + let ty = match remaining_segments.len() { + 1 => { + let trait_ref = + self.lower_trait_ref_from_resolved_path(trait_, resolved_segment, None); + let segment = remaining_segments.first().unwrap(); + let found = self + .db + .trait_data(trait_ref.hir_trait_id()) + .associated_type_by_name(segment.name); + match found { + Some(associated_ty) => { + // FIXME handle type parameters on the segment + TyKind::Alias(AliasTy::Projection(ProjectionTy { + associated_ty_id: to_assoc_type_id(associated_ty), + substitution: trait_ref.substitution, + })) + .intern(Interner) + } + None => { + // FIXME: report error (associated type not found) + TyKind::Error.intern(Interner) + } + } + } + 0 => { + let self_ty = Some( + TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)) + .intern(Interner), + ); + let trait_ref = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { + ctx.lower_trait_ref_from_resolved_path( + trait_, + resolved_segment, + self_ty, + ) + }); + let dyn_ty = DynTy { + bounds: crate::make_single_type_binders( + QuantifiedWhereClauses::from_iter( + Interner, + Some(crate::wrap_empty_binders(WhereClause::Implemented( + trait_ref, + ))), + ), + ), + lifetime: static_lifetime(), + }; + TyKind::Dyn(dyn_ty).intern(Interner) + } + _ => { + // FIXME report error (ambiguous associated type) + TyKind::Error.intern(Interner) + } + }; + return (ty, None); + } + TypeNs::GenericParam(param_id) => { + let generics = generics( + self.db.upcast(), + self.resolver.generic_def().expect("generics in scope"), + ); + match self.type_param_mode { + ParamLoweringMode::Placeholder => { + TyKind::Placeholder(to_placeholder_idx(self.db, param_id.into())) + } + ParamLoweringMode::Variable => { + let idx = generics.param_idx(param_id.into()).expect("matching generics"); + TyKind::BoundVar(BoundVar::new(self.in_binders, idx)) + } + } + .intern(Interner) + } + TypeNs::SelfType(impl_id) => { + let generics = generics(self.db.upcast(), impl_id.into()); + let substs = match self.type_param_mode { + ParamLoweringMode::Placeholder => generics.placeholder_subst(self.db), + ParamLoweringMode::Variable => { + generics.bound_vars_subst(self.db, self.in_binders) + } + }; + self.db.impl_self_ty(impl_id).substitute(Interner, &substs) + } + TypeNs::AdtSelfType(adt) => { + let generics = generics(self.db.upcast(), adt.into()); + let substs = match self.type_param_mode { + ParamLoweringMode::Placeholder => generics.placeholder_subst(self.db), + ParamLoweringMode::Variable => { + generics.bound_vars_subst(self.db, self.in_binders) + } + }; + self.db.ty(adt.into()).substitute(Interner, &substs) + } + + TypeNs::AdtId(it) => self.lower_path_inner(resolved_segment, it.into(), infer_args), + TypeNs::BuiltinType(it) => { + self.lower_path_inner(resolved_segment, it.into(), infer_args) + } + TypeNs::TypeAliasId(it) => { + self.lower_path_inner(resolved_segment, it.into(), infer_args) + } + // FIXME: report error + TypeNs::EnumVariantId(_) => return (TyKind::Error.intern(Interner), None), + }; + self.lower_ty_relative_path(ty, Some(resolution), remaining_segments) + } + + pub(crate) fn lower_path(&self, path: &Path) -> (Ty, Option<TypeNs>) { + // Resolve the path (in type namespace) + if let Some(type_ref) = path.type_anchor() { + let (ty, res) = self.lower_ty_ext(type_ref); + return self.lower_ty_relative_path(ty, res, path.segments()); + } + let (resolution, remaining_index) = + match self.resolver.resolve_path_in_type_ns(self.db.upcast(), path.mod_path()) { + Some(it) => it, + None => return (TyKind::Error.intern(Interner), None), + }; + let (resolved_segment, remaining_segments) = match remaining_index { + None => ( + path.segments().last().expect("resolved path has at least one element"), + PathSegments::EMPTY, + ), + Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)), + }; + self.lower_partly_resolved_path(resolution, resolved_segment, remaining_segments, false) + } + + fn select_associated_type(&self, res: Option<TypeNs>, segment: PathSegment<'_>) -> Ty { + let (def, res) = match (self.resolver.generic_def(), res) { + (Some(def), Some(res)) => (def, res), + _ => return TyKind::Error.intern(Interner), + }; + let ty = named_associated_type_shorthand_candidates( + self.db, + def, + res, + Some(segment.name.clone()), + move |name, t, associated_ty| { + if name == segment.name { + let substs = match self.type_param_mode { + ParamLoweringMode::Placeholder => { + // if we're lowering to placeholders, we have to put + // them in now + let generics = generics( + self.db.upcast(), + self.resolver + .generic_def() + .expect("there should be generics if there's a generic param"), + ); + let s = generics.placeholder_subst(self.db); + s.apply(t.substitution.clone(), Interner) + } + ParamLoweringMode::Variable => t.substitution.clone(), + }; + // We need to shift in the bound vars, since + // associated_type_shorthand_candidates does not do that + let substs = substs.shifted_in_from(Interner, self.in_binders); + // FIXME handle type parameters on the segment + Some( + TyKind::Alias(AliasTy::Projection(ProjectionTy { + associated_ty_id: to_assoc_type_id(associated_ty), + substitution: substs, + })) + .intern(Interner), + ) + } else { + None + } + }, + ); + + ty.unwrap_or_else(|| TyKind::Error.intern(Interner)) + } + + fn lower_path_inner( + &self, + segment: PathSegment<'_>, + typeable: TyDefId, + infer_args: bool, + ) -> Ty { + let generic_def = match typeable { + TyDefId::BuiltinType(_) => None, + TyDefId::AdtId(it) => Some(it.into()), + TyDefId::TypeAliasId(it) => Some(it.into()), + }; + let substs = self.substs_from_path_segment(segment, generic_def, infer_args, None); + self.db.ty(typeable).substitute(Interner, &substs) + } + + /// Collect generic arguments from a path into a `Substs`. See also + /// `create_substs_for_ast_path` and `def_to_ty` in rustc. + pub(super) fn substs_from_path( + &self, + path: &Path, + // Note that we don't call `db.value_type(resolved)` here, + // `ValueTyDefId` is just a convenient way to pass generics and + // special-case enum variants + resolved: ValueTyDefId, + infer_args: bool, + ) -> Substitution { + let last = path.segments().last().expect("path should have at least one segment"); + let (segment, generic_def) = match resolved { + ValueTyDefId::FunctionId(it) => (last, Some(it.into())), + ValueTyDefId::StructId(it) => (last, Some(it.into())), + ValueTyDefId::UnionId(it) => (last, Some(it.into())), + ValueTyDefId::ConstId(it) => (last, Some(it.into())), + ValueTyDefId::StaticId(_) => (last, None), + ValueTyDefId::EnumVariantId(var) => { + // the generic args for an enum variant may be either specified + // on the segment referring to the enum, or on the segment + // referring to the variant. So `Option::<T>::None` and + // `Option::None::<T>` are both allowed (though the former is + // preferred). See also `def_ids_for_path_segments` in rustc. + let len = path.segments().len(); + let penultimate = len.checked_sub(2).and_then(|idx| path.segments().get(idx)); + let segment = match penultimate { + Some(segment) if segment.args_and_bindings.is_some() => segment, + _ => last, + }; + (segment, Some(var.parent.into())) + } + }; + self.substs_from_path_segment(segment, generic_def, infer_args, None) + } + + fn substs_from_path_segment( + &self, + segment: PathSegment<'_>, + def_generic: Option<GenericDefId>, + infer_args: bool, + explicit_self_ty: Option<Ty>, + ) -> Substitution { + let mut substs = Vec::new(); + let def_generics = if let Some(def) = def_generic { + generics(self.db.upcast(), def) + } else { + return Substitution::empty(Interner); + }; + let (parent_params, self_params, type_params, const_params, impl_trait_params) = + def_generics.provenance_split(); + let total_len = + parent_params + self_params + type_params + const_params + impl_trait_params; + + let ty_error = GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner); + + let mut def_generic_iter = def_generics.iter_id(); + + for _ in 0..parent_params { + if let Some(eid) = def_generic_iter.next() { + match eid { + Either::Left(_) => substs.push(ty_error.clone()), + Either::Right(x) => { + substs.push(unknown_const_as_generic(self.db.const_param_ty(x))) + } + } + } + } + + let fill_self_params = || { + for x in explicit_self_ty + .into_iter() + .map(|x| GenericArgData::Ty(x).intern(Interner)) + .chain(iter::repeat(ty_error.clone())) + .take(self_params) + { + if let Some(id) = def_generic_iter.next() { + assert!(id.is_left()); + substs.push(x); + } + } + }; + let mut had_explicit_args = false; + + if let Some(generic_args) = &segment.args_and_bindings { + if !generic_args.has_self_type { + fill_self_params(); + } + let expected_num = if generic_args.has_self_type { + self_params + type_params + const_params + } else { + type_params + const_params + }; + let skip = if generic_args.has_self_type && self_params == 0 { 1 } else { 0 }; + // if args are provided, it should be all of them, but we can't rely on that + for arg in generic_args + .args + .iter() + .filter(|arg| !matches!(arg, GenericArg::Lifetime(_))) + .skip(skip) + .take(expected_num) + { + if let Some(id) = def_generic_iter.next() { + if let Some(x) = generic_arg_to_chalk( + self.db, + id, + arg, + &mut (), + |_, type_ref| self.lower_ty(type_ref), + |_, c, ty| { + const_or_path_to_chalk( + self.db, + &self.resolver, + ty, + c, + self.type_param_mode, + || self.generics(), + self.in_binders, + ) + }, + ) { + had_explicit_args = true; + substs.push(x); + } else { + // we just filtered them out + never!("Unexpected lifetime argument"); + } + } + } + } else { + fill_self_params(); + } + + // handle defaults. In expression or pattern path segments without + // explicitly specified type arguments, missing type arguments are inferred + // (i.e. defaults aren't used). + if !infer_args || had_explicit_args { + if let Some(def_generic) = def_generic { + let defaults = self.db.generic_defaults(def_generic); + assert_eq!(total_len, defaults.len()); + + for default_ty in defaults.iter().skip(substs.len()) { + // each default can depend on the previous parameters + let substs_so_far = Substitution::from_iter(Interner, substs.clone()); + if let Some(_id) = def_generic_iter.next() { + substs.push(default_ty.clone().substitute(Interner, &substs_so_far)); + } + } + } + } + + // add placeholders for args that were not provided + // FIXME: emit diagnostics in contexts where this is not allowed + for eid in def_generic_iter { + match eid { + Either::Left(_) => substs.push(ty_error.clone()), + Either::Right(x) => { + substs.push(unknown_const_as_generic(self.db.const_param_ty(x))) + } + } + } + // If this assert fails, it means you pushed into subst but didn't call .next() of def_generic_iter + assert_eq!(substs.len(), total_len); + + Substitution::from_iter(Interner, substs) + } + + fn lower_trait_ref_from_path( + &self, + path: &Path, + explicit_self_ty: Option<Ty>, + ) -> Option<TraitRef> { + let resolved = + match self.resolver.resolve_path_in_type_ns_fully(self.db.upcast(), path.mod_path())? { + TypeNs::TraitId(tr) => tr, + _ => return None, + }; + let segment = path.segments().last().expect("path should have at least one segment"); + Some(self.lower_trait_ref_from_resolved_path(resolved, segment, explicit_self_ty)) + } + + pub(crate) fn lower_trait_ref_from_resolved_path( + &self, + resolved: TraitId, + segment: PathSegment<'_>, + explicit_self_ty: Option<Ty>, + ) -> TraitRef { + let substs = self.trait_ref_substs_from_path(segment, resolved, explicit_self_ty); + TraitRef { trait_id: to_chalk_trait_id(resolved), substitution: substs } + } + + fn lower_trait_ref( + &self, + trait_ref: &HirTraitRef, + explicit_self_ty: Option<Ty>, + ) -> Option<TraitRef> { + self.lower_trait_ref_from_path(&trait_ref.path, explicit_self_ty) + } + + fn trait_ref_substs_from_path( + &self, + segment: PathSegment<'_>, + resolved: TraitId, + explicit_self_ty: Option<Ty>, + ) -> Substitution { + self.substs_from_path_segment(segment, Some(resolved.into()), false, explicit_self_ty) + } + + pub(crate) fn lower_where_predicate( + &'a self, + where_predicate: &'a WherePredicate, + ignore_bindings: bool, + ) -> impl Iterator<Item = QuantifiedWhereClause> + 'a { + match where_predicate { + WherePredicate::ForLifetime { target, bound, .. } + | WherePredicate::TypeBound { target, bound } => { + let self_ty = match target { + WherePredicateTypeTarget::TypeRef(type_ref) => self.lower_ty(type_ref), + WherePredicateTypeTarget::TypeOrConstParam(param_id) => { + let generic_def = self.resolver.generic_def().expect("generics in scope"); + let generics = generics(self.db.upcast(), generic_def); + let param_id = hir_def::TypeOrConstParamId { + parent: generic_def, + local_id: *param_id, + }; + let placeholder = to_placeholder_idx(self.db, param_id); + match self.type_param_mode { + ParamLoweringMode::Placeholder => TyKind::Placeholder(placeholder), + ParamLoweringMode::Variable => { + let idx = generics.param_idx(param_id).expect("matching generics"); + TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, idx)) + } + } + .intern(Interner) + } + }; + self.lower_type_bound(bound, self_ty, ignore_bindings) + .collect::<Vec<_>>() + .into_iter() + } + WherePredicate::Lifetime { .. } => vec![].into_iter(), + } + } + + pub(crate) fn lower_type_bound( + &'a self, + bound: &'a TypeBound, + self_ty: Ty, + ignore_bindings: bool, + ) -> impl Iterator<Item = QuantifiedWhereClause> + 'a { + let mut bindings = None; + let trait_ref = match bound { + TypeBound::Path(path, TraitBoundModifier::None) => { + bindings = self.lower_trait_ref_from_path(path, Some(self_ty)); + bindings + .clone() + .filter(|tr| { + // ignore `T: Drop` or `T: Destruct` bounds. + // - `T: ~const Drop` has a special meaning in Rust 1.61 that we don't implement. + // (So ideally, we'd only ignore `~const Drop` here) + // - `Destruct` impls are built-in in 1.62 (current nightlies as of 08-04-2022), so until + // the builtin impls are supported by Chalk, we ignore them here. + if let Some(lang) = lang_attr(self.db.upcast(), tr.hir_trait_id()) { + if lang == "drop" || lang == "destruct" { + return false; + } + } + true + }) + .map(WhereClause::Implemented) + .map(crate::wrap_empty_binders) + } + TypeBound::Path(path, TraitBoundModifier::Maybe) => { + let sized_trait = self + .db + .lang_item(self.resolver.krate(), SmolStr::new_inline("sized")) + .and_then(|lang_item| lang_item.as_trait()); + // Don't lower associated type bindings as the only possible relaxed trait bound + // `?Sized` has no of them. + // If we got another trait here ignore the bound completely. + let trait_id = self + .lower_trait_ref_from_path(path, Some(self_ty.clone())) + .map(|trait_ref| trait_ref.hir_trait_id()); + if trait_id == sized_trait { + self.unsized_types.borrow_mut().insert(self_ty); + } + None + } + TypeBound::ForLifetime(_, path) => { + // FIXME Don't silently drop the hrtb lifetimes here + bindings = self.lower_trait_ref_from_path(path, Some(self_ty)); + bindings.clone().map(WhereClause::Implemented).map(crate::wrap_empty_binders) + } + TypeBound::Lifetime(_) => None, + TypeBound::Error => None, + }; + trait_ref.into_iter().chain( + bindings + .into_iter() + .filter(move |_| !ignore_bindings) + .flat_map(move |tr| self.assoc_type_bindings_from_type_bound(bound, tr)), + ) + } + + fn assoc_type_bindings_from_type_bound( + &'a self, + bound: &'a TypeBound, + trait_ref: TraitRef, + ) -> impl Iterator<Item = QuantifiedWhereClause> + 'a { + let last_segment = match bound { + TypeBound::Path(path, TraitBoundModifier::None) | TypeBound::ForLifetime(_, path) => { + path.segments().last() + } + TypeBound::Path(_, TraitBoundModifier::Maybe) + | TypeBound::Error + | TypeBound::Lifetime(_) => None, + }; + last_segment + .into_iter() + .filter_map(|segment| segment.args_and_bindings) + .flat_map(|args_and_bindings| &args_and_bindings.bindings) + .flat_map(move |binding| { + let found = associated_type_by_name_including_super_traits( + self.db, + trait_ref.clone(), + &binding.name, + ); + let (super_trait_ref, associated_ty) = match found { + None => return SmallVec::new(), + Some(t) => t, + }; + let projection_ty = ProjectionTy { + associated_ty_id: to_assoc_type_id(associated_ty), + substitution: super_trait_ref.substitution, + }; + let mut preds: SmallVec<[_; 1]> = SmallVec::with_capacity( + binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(), + ); + if let Some(type_ref) = &binding.type_ref { + let ty = self.lower_ty(type_ref); + let alias_eq = + AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty }; + preds.push(crate::wrap_empty_binders(WhereClause::AliasEq(alias_eq))); + } + for bound in &binding.bounds { + preds.extend(self.lower_type_bound( + bound, + TyKind::Alias(AliasTy::Projection(projection_ty.clone())).intern(Interner), + false, + )); + } + preds + }) + } + + fn lower_impl_trait( + &self, + bounds: &[Interned<TypeBound>], + func: FunctionId, + ) -> ReturnTypeImplTrait { + cov_mark::hit!(lower_rpit); + let self_ty = TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(Interner); + let predicates = self.with_shifted_in(DebruijnIndex::ONE, |ctx| { + let mut predicates: Vec<_> = bounds + .iter() + .flat_map(|b| ctx.lower_type_bound(b, self_ty.clone(), false)) + .collect(); + + if !ctx.unsized_types.borrow().contains(&self_ty) { + let krate = func.lookup(ctx.db.upcast()).module(ctx.db.upcast()).krate(); + let sized_trait = ctx + .db + .lang_item(krate, SmolStr::new_inline("sized")) + .and_then(|lang_item| lang_item.as_trait().map(to_chalk_trait_id)); + let sized_clause = sized_trait.map(|trait_id| { + let clause = WhereClause::Implemented(TraitRef { + trait_id, + substitution: Substitution::from1(Interner, self_ty.clone()), + }); + crate::wrap_empty_binders(clause) + }); + predicates.extend(sized_clause.into_iter()); + predicates.shrink_to_fit(); + } + predicates + }); + ReturnTypeImplTrait { bounds: crate::make_single_type_binders(predicates) } + } +} + +fn count_impl_traits(type_ref: &TypeRef) -> usize { + let mut count = 0; + type_ref.walk(&mut |type_ref| { + if matches!(type_ref, TypeRef::ImplTrait(_)) { + count += 1; + } + }); + count +} + +/// Build the signature of a callable item (function, struct or enum variant). +pub(crate) fn callable_item_sig(db: &dyn HirDatabase, def: CallableDefId) -> PolyFnSig { + match def { + CallableDefId::FunctionId(f) => fn_sig_for_fn(db, f), + CallableDefId::StructId(s) => fn_sig_for_struct_constructor(db, s), + CallableDefId::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e), + } +} + +pub fn associated_type_shorthand_candidates<R>( + db: &dyn HirDatabase, + def: GenericDefId, + res: TypeNs, + cb: impl FnMut(&Name, &TraitRef, TypeAliasId) -> Option<R>, +) -> Option<R> { + named_associated_type_shorthand_candidates(db, def, res, None, cb) +} + +fn named_associated_type_shorthand_candidates<R>( + db: &dyn HirDatabase, + // If the type parameter is defined in an impl and we're in a method, there + // might be additional where clauses to consider + def: GenericDefId, + res: TypeNs, + assoc_name: Option<Name>, + mut cb: impl FnMut(&Name, &TraitRef, TypeAliasId) -> Option<R>, +) -> Option<R> { + let mut search = |t| { + for t in all_super_trait_refs(db, t) { + let data = db.trait_data(t.hir_trait_id()); + + for (name, assoc_id) in &data.items { + if let AssocItemId::TypeAliasId(alias) = assoc_id { + if let Some(result) = cb(name, &t, *alias) { + return Some(result); + } + } + } + } + None + }; + + match res { + TypeNs::SelfType(impl_id) => search( + // we're _in_ the impl -- the binders get added back later. Correct, + // but it would be nice to make this more explicit + db.impl_trait(impl_id)?.into_value_and_skipped_binders().0, + ), + TypeNs::GenericParam(param_id) => { + let predicates = db.generic_predicates_for_param(def, param_id.into(), assoc_name); + let res = predicates.iter().find_map(|pred| match pred.skip_binders().skip_binders() { + // FIXME: how to correctly handle higher-ranked bounds here? + WhereClause::Implemented(tr) => search( + tr.clone() + .shifted_out_to(Interner, DebruijnIndex::ONE) + .expect("FIXME unexpected higher-ranked trait bound"), + ), + _ => None, + }); + if let Some(_) = res { + return res; + } + // Handle `Self::Type` referring to own associated type in trait definitions + if let GenericDefId::TraitId(trait_id) = param_id.parent() { + let generics = generics(db.upcast(), trait_id.into()); + if generics.params.type_or_consts[param_id.local_id()].is_trait_self() { + let trait_ref = TyBuilder::trait_ref(db, trait_id) + .fill_with_bound_vars(DebruijnIndex::INNERMOST, 0) + .build(); + return search(trait_ref); + } + } + None + } + _ => None, + } +} + +/// Build the type of all specific fields of a struct or enum variant. +pub(crate) fn field_types_query( + db: &dyn HirDatabase, + variant_id: VariantId, +) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>> { + let var_data = variant_id.variant_data(db.upcast()); + let (resolver, def): (_, GenericDefId) = match variant_id { + VariantId::StructId(it) => (it.resolver(db.upcast()), it.into()), + VariantId::UnionId(it) => (it.resolver(db.upcast()), it.into()), + VariantId::EnumVariantId(it) => (it.parent.resolver(db.upcast()), it.parent.into()), + }; + let generics = generics(db.upcast(), def); + let mut res = ArenaMap::default(); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + for (field_id, field_data) in var_data.fields().iter() { + res.insert(field_id, make_binders(db, &generics, ctx.lower_ty(&field_data.type_ref))) + } + Arc::new(res) +} + +/// This query exists only to be used when resolving short-hand associated types +/// like `T::Item`. +/// +/// See the analogous query in rustc and its comment: +/// <https://github.com/rust-lang/rust/blob/9150f844e2624eb013ec78ca08c1d416e6644026/src/librustc_typeck/astconv.rs#L46> +/// This is a query mostly to handle cycles somewhat gracefully; e.g. the +/// following bounds are disallowed: `T: Foo<U::Item>, U: Foo<T::Item>`, but +/// these are fine: `T: Foo<U::Item>, U: Foo<()>`. +pub(crate) fn generic_predicates_for_param_query( + db: &dyn HirDatabase, + def: GenericDefId, + param_id: TypeOrConstParamId, + assoc_name: Option<Name>, +) -> Arc<[Binders<QuantifiedWhereClause>]> { + let resolver = def.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + let generics = generics(db.upcast(), def); + let mut predicates: Vec<_> = resolver + .where_predicates_in_scope() + // we have to filter out all other predicates *first*, before attempting to lower them + .filter(|pred| match pred { + WherePredicate::ForLifetime { target, bound, .. } + | WherePredicate::TypeBound { target, bound, .. } => { + match target { + WherePredicateTypeTarget::TypeRef(type_ref) => { + if ctx.lower_ty_only_param(type_ref) != Some(param_id) { + return false; + } + } + &WherePredicateTypeTarget::TypeOrConstParam(local_id) => { + let target_id = TypeOrConstParamId { parent: def, local_id }; + if target_id != param_id { + return false; + } + } + }; + + match &**bound { + TypeBound::ForLifetime(_, path) | TypeBound::Path(path, _) => { + // Only lower the bound if the trait could possibly define the associated + // type we're looking for. + + let assoc_name = match &assoc_name { + Some(it) => it, + None => return true, + }; + let tr = match resolver + .resolve_path_in_type_ns_fully(db.upcast(), path.mod_path()) + { + Some(TypeNs::TraitId(tr)) => tr, + _ => return false, + }; + + all_super_traits(db.upcast(), tr).iter().any(|tr| { + db.trait_data(*tr).items.iter().any(|(name, item)| { + matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name + }) + }) + } + TypeBound::Lifetime(_) | TypeBound::Error => false, + } + } + WherePredicate::Lifetime { .. } => false, + }) + .flat_map(|pred| { + ctx.lower_where_predicate(pred, true).map(|p| make_binders(db, &generics, p)) + }) + .collect(); + + let subst = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST); + let explicitly_unsized_tys = ctx.unsized_types.into_inner(); + let implicitly_sized_predicates = + implicitly_sized_clauses(db, param_id.parent, &explicitly_unsized_tys, &subst, &resolver) + .map(|p| make_binders(db, &generics, crate::wrap_empty_binders(p))); + predicates.extend(implicitly_sized_predicates); + predicates.into() +} + +pub(crate) fn generic_predicates_for_param_recover( + _db: &dyn HirDatabase, + _cycle: &[String], + _def: &GenericDefId, + _param_id: &TypeOrConstParamId, + _assoc_name: &Option<Name>, +) -> Arc<[Binders<QuantifiedWhereClause>]> { + Arc::new([]) +} + +pub(crate) fn trait_environment_query( + db: &dyn HirDatabase, + def: GenericDefId, +) -> Arc<TraitEnvironment> { + let resolver = def.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Placeholder); + let mut traits_in_scope = Vec::new(); + let mut clauses = Vec::new(); + for pred in resolver.where_predicates_in_scope() { + for pred in ctx.lower_where_predicate(pred, false) { + if let WhereClause::Implemented(tr) = &pred.skip_binders() { + traits_in_scope.push((tr.self_type_parameter(Interner).clone(), tr.hir_trait_id())); + } + let program_clause: chalk_ir::ProgramClause<Interner> = pred.cast(Interner); + clauses.push(program_clause.into_from_env_clause(Interner)); + } + } + + let container: Option<ItemContainerId> = match def { + // FIXME: is there a function for this? + GenericDefId::FunctionId(f) => Some(f.lookup(db.upcast()).container), + GenericDefId::AdtId(_) => None, + GenericDefId::TraitId(_) => None, + GenericDefId::TypeAliasId(t) => Some(t.lookup(db.upcast()).container), + GenericDefId::ImplId(_) => None, + GenericDefId::EnumVariantId(_) => None, + GenericDefId::ConstId(c) => Some(c.lookup(db.upcast()).container), + }; + if let Some(ItemContainerId::TraitId(trait_id)) = container { + // add `Self: Trait<T1, T2, ...>` to the environment in trait + // function default implementations (and speculative code + // inside consts or type aliases) + cov_mark::hit!(trait_self_implements_self); + let substs = TyBuilder::placeholder_subst(db, trait_id); + let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs }; + let pred = WhereClause::Implemented(trait_ref); + let program_clause: chalk_ir::ProgramClause<Interner> = pred.cast(Interner); + clauses.push(program_clause.into_from_env_clause(Interner)); + } + + let subst = generics(db.upcast(), def).placeholder_subst(db); + let explicitly_unsized_tys = ctx.unsized_types.into_inner(); + let implicitly_sized_clauses = + implicitly_sized_clauses(db, def, &explicitly_unsized_tys, &subst, &resolver).map(|pred| { + let program_clause: chalk_ir::ProgramClause<Interner> = pred.cast(Interner); + program_clause.into_from_env_clause(Interner) + }); + clauses.extend(implicitly_sized_clauses); + + let krate = def.module(db.upcast()).krate(); + + let env = chalk_ir::Environment::new(Interner).add_clauses(Interner, clauses); + + Arc::new(TraitEnvironment { krate, traits_from_clauses: traits_in_scope, env }) +} + +/// Resolve the where clause(s) of an item with generics. +pub(crate) fn generic_predicates_query( + db: &dyn HirDatabase, + def: GenericDefId, +) -> Arc<[Binders<QuantifiedWhereClause>]> { + let resolver = def.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + let generics = generics(db.upcast(), def); + + let mut predicates = resolver + .where_predicates_in_scope() + .flat_map(|pred| { + ctx.lower_where_predicate(pred, false).map(|p| make_binders(db, &generics, p)) + }) + .collect::<Vec<_>>(); + + let subst = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST); + let explicitly_unsized_tys = ctx.unsized_types.into_inner(); + let implicitly_sized_predicates = + implicitly_sized_clauses(db, def, &explicitly_unsized_tys, &subst, &resolver) + .map(|p| make_binders(db, &generics, crate::wrap_empty_binders(p))); + predicates.extend(implicitly_sized_predicates); + predicates.into() +} + +/// Generate implicit `: Sized` predicates for all generics that has no `?Sized` bound. +/// Exception is Self of a trait def. +fn implicitly_sized_clauses<'a>( + db: &dyn HirDatabase, + def: GenericDefId, + explicitly_unsized_tys: &'a FxHashSet<Ty>, + substitution: &'a Substitution, + resolver: &Resolver, +) -> impl Iterator<Item = WhereClause> + 'a { + let is_trait_def = matches!(def, GenericDefId::TraitId(..)); + let generic_args = &substitution.as_slice(Interner)[is_trait_def as usize..]; + let sized_trait = db + .lang_item(resolver.krate(), SmolStr::new_inline("sized")) + .and_then(|lang_item| lang_item.as_trait().map(to_chalk_trait_id)); + + sized_trait.into_iter().flat_map(move |sized_trait| { + let implicitly_sized_tys = generic_args + .iter() + .filter_map(|generic_arg| generic_arg.ty(Interner)) + .filter(move |&self_ty| !explicitly_unsized_tys.contains(self_ty)); + implicitly_sized_tys.map(move |self_ty| { + WhereClause::Implemented(TraitRef { + trait_id: sized_trait, + substitution: Substitution::from1(Interner, self_ty.clone()), + }) + }) + }) +} + +/// Resolve the default type params from generics +pub(crate) fn generic_defaults_query( + db: &dyn HirDatabase, + def: GenericDefId, +) -> Arc<[Binders<chalk_ir::GenericArg<Interner>>]> { + let resolver = def.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + let generic_params = generics(db.upcast(), def); + + let defaults = generic_params + .iter() + .enumerate() + .map(|(idx, (id, p))| { + let p = match p { + TypeOrConstParamData::TypeParamData(p) => p, + TypeOrConstParamData::ConstParamData(_) => { + // FIXME: implement const generic defaults + let val = unknown_const_as_generic( + db.const_param_ty(ConstParamId::from_unchecked(id)), + ); + return crate::make_binders_with_count(db, idx, &generic_params, val); + } + }; + let mut ty = + p.default.as_ref().map_or(TyKind::Error.intern(Interner), |t| ctx.lower_ty(t)); + + // Each default can only refer to previous parameters. + // type variable default referring to parameter coming + // after it. This is forbidden (FIXME: report + // diagnostic) + ty = fallback_bound_vars(ty, idx); + let val = GenericArgData::Ty(ty).intern(Interner); + crate::make_binders_with_count(db, idx, &generic_params, val) + }) + .collect(); + + defaults +} + +pub(crate) fn generic_defaults_recover( + db: &dyn HirDatabase, + _cycle: &[String], + def: &GenericDefId, +) -> Arc<[Binders<crate::GenericArg>]> { + let generic_params = generics(db.upcast(), *def); + // FIXME: this code is not covered in tests. + // we still need one default per parameter + let defaults = generic_params + .iter_id() + .enumerate() + .map(|(count, id)| { + let val = match id { + itertools::Either::Left(_) => { + GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner) + } + itertools::Either::Right(id) => unknown_const_as_generic(db.const_param_ty(id)), + }; + crate::make_binders_with_count(db, count, &generic_params, val) + }) + .collect(); + + defaults +} + +fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig { + let data = db.function_data(def); + let resolver = def.resolver(db.upcast()); + let ctx_params = TyLoweringContext::new(db, &resolver) + .with_impl_trait_mode(ImplTraitLoweringMode::Variable) + .with_type_param_mode(ParamLoweringMode::Variable); + let params = data.params.iter().map(|(_, tr)| ctx_params.lower_ty(tr)).collect::<Vec<_>>(); + let ctx_ret = TyLoweringContext::new(db, &resolver) + .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) + .with_type_param_mode(ParamLoweringMode::Variable); + let ret = ctx_ret.lower_ty(&data.ret_type); + let generics = generics(db.upcast(), def.into()); + let sig = CallableSig::from_params_and_return(params, ret, data.is_varargs()); + make_binders(db, &generics, sig) +} + +/// Build the declared type of a function. This should not need to look at the +/// function body. +fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> { + let generics = generics(db.upcast(), def.into()); + let substs = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST); + make_binders( + db, + &generics, + TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(Interner), + ) +} + +/// Build the declared type of a const. +fn type_for_const(db: &dyn HirDatabase, def: ConstId) -> Binders<Ty> { + let data = db.const_data(def); + let generics = generics(db.upcast(), def.into()); + let resolver = def.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + + make_binders(db, &generics, ctx.lower_ty(&data.type_ref)) +} + +/// Build the declared type of a static. +fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> Binders<Ty> { + let data = db.static_data(def); + let resolver = def.resolver(db.upcast()); + let ctx = TyLoweringContext::new(db, &resolver); + + Binders::empty(Interner, ctx.lower_ty(&data.type_ref)) +} + +fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig { + let struct_data = db.struct_data(def); + let fields = struct_data.variant_data.fields(); + let resolver = def.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>(); + let (ret, binders) = type_for_adt(db, def.into()).into_value_and_skipped_binders(); + Binders::new(binders, CallableSig::from_params_and_return(params, ret, false)) +} + +/// Build the type of a tuple struct constructor. +fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Binders<Ty> { + let struct_data = db.struct_data(def); + if let StructKind::Unit = struct_data.variant_data.kind() { + return type_for_adt(db, def.into()); + } + let generics = generics(db.upcast(), def.into()); + let substs = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST); + make_binders( + db, + &generics, + TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(Interner), + ) +} + +fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig { + let enum_data = db.enum_data(def.parent); + let var_data = &enum_data.variants[def.local_id]; + let fields = var_data.variant_data.fields(); + let resolver = def.parent.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + let params = fields.iter().map(|(_, field)| ctx.lower_ty(&field.type_ref)).collect::<Vec<_>>(); + let (ret, binders) = type_for_adt(db, def.parent.into()).into_value_and_skipped_binders(); + Binders::new(binders, CallableSig::from_params_and_return(params, ret, false)) +} + +/// Build the type of a tuple enum variant constructor. +fn type_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> Binders<Ty> { + let enum_data = db.enum_data(def.parent); + let var_data = &enum_data.variants[def.local_id].variant_data; + if let StructKind::Unit = var_data.kind() { + return type_for_adt(db, def.parent.into()); + } + let generics = generics(db.upcast(), def.parent.into()); + let substs = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST); + make_binders( + db, + &generics, + TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs).intern(Interner), + ) +} + +fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> { + let generics = generics(db.upcast(), adt.into()); + let subst = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST); + let ty = TyKind::Adt(crate::AdtId(adt), subst).intern(Interner); + make_binders(db, &generics, ty) +} + +fn type_for_type_alias(db: &dyn HirDatabase, t: TypeAliasId) -> Binders<Ty> { + let generics = generics(db.upcast(), t.into()); + let resolver = t.resolver(db.upcast()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + if db.type_alias_data(t).is_extern { + Binders::empty(Interner, TyKind::Foreign(crate::to_foreign_def_id(t)).intern(Interner)) + } else { + let type_ref = &db.type_alias_data(t).type_ref; + let inner = ctx.lower_ty(type_ref.as_deref().unwrap_or(&TypeRef::Error)); + make_binders(db, &generics, inner) + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum CallableDefId { + FunctionId(FunctionId), + StructId(StructId), + EnumVariantId(EnumVariantId), +} +impl_from!(FunctionId, StructId, EnumVariantId for CallableDefId); + +impl CallableDefId { + pub fn krate(self, db: &dyn HirDatabase) -> CrateId { + let db = db.upcast(); + match self { + CallableDefId::FunctionId(f) => f.lookup(db).module(db), + CallableDefId::StructId(s) => s.lookup(db).container, + CallableDefId::EnumVariantId(e) => e.parent.lookup(db).container, + } + .krate() + } +} + +impl From<CallableDefId> for GenericDefId { + fn from(def: CallableDefId) -> GenericDefId { + match def { + CallableDefId::FunctionId(f) => f.into(), + CallableDefId::StructId(s) => s.into(), + CallableDefId::EnumVariantId(e) => e.into(), + } + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum TyDefId { + BuiltinType(BuiltinType), + AdtId(AdtId), + TypeAliasId(TypeAliasId), +} +impl_from!(BuiltinType, AdtId(StructId, EnumId, UnionId), TypeAliasId for TyDefId); + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum ValueTyDefId { + FunctionId(FunctionId), + StructId(StructId), + UnionId(UnionId), + EnumVariantId(EnumVariantId), + ConstId(ConstId), + StaticId(StaticId), +} +impl_from!(FunctionId, StructId, UnionId, EnumVariantId, ConstId, StaticId for ValueTyDefId); + +/// Build the declared type of an item. This depends on the namespace; e.g. for +/// `struct Foo(usize)`, we have two types: The type of the struct itself, and +/// the constructor function `(usize) -> Foo` which lives in the values +/// namespace. +pub(crate) fn ty_query(db: &dyn HirDatabase, def: TyDefId) -> Binders<Ty> { + match def { + TyDefId::BuiltinType(it) => Binders::empty(Interner, TyBuilder::builtin(it)), + TyDefId::AdtId(it) => type_for_adt(db, it), + TyDefId::TypeAliasId(it) => type_for_type_alias(db, it), + } +} + +pub(crate) fn ty_recover(db: &dyn HirDatabase, _cycle: &[String], def: &TyDefId) -> Binders<Ty> { + let generics = match *def { + TyDefId::BuiltinType(_) => return Binders::empty(Interner, TyKind::Error.intern(Interner)), + TyDefId::AdtId(it) => generics(db.upcast(), it.into()), + TyDefId::TypeAliasId(it) => generics(db.upcast(), it.into()), + }; + make_binders(db, &generics, TyKind::Error.intern(Interner)) +} + +pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Binders<Ty> { + match def { + ValueTyDefId::FunctionId(it) => type_for_fn(db, it), + ValueTyDefId::StructId(it) => type_for_struct_constructor(db, it), + ValueTyDefId::UnionId(it) => type_for_adt(db, it.into()), + ValueTyDefId::EnumVariantId(it) => type_for_enum_variant_constructor(db, it), + ValueTyDefId::ConstId(it) => type_for_const(db, it), + ValueTyDefId::StaticId(it) => type_for_static(db, it), + } +} + +pub(crate) fn impl_self_ty_query(db: &dyn HirDatabase, impl_id: ImplId) -> Binders<Ty> { + let impl_loc = impl_id.lookup(db.upcast()); + let impl_data = db.impl_data(impl_id); + let resolver = impl_id.resolver(db.upcast()); + let _cx = stdx::panic_context::enter(format!( + "impl_self_ty_query({:?} -> {:?} -> {:?})", + impl_id, impl_loc, impl_data + )); + let generics = generics(db.upcast(), impl_id.into()); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + make_binders(db, &generics, ctx.lower_ty(&impl_data.self_ty)) +} + +// returns None if def is a type arg +pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty { + let parent_data = db.generic_params(def.parent()); + let data = &parent_data.type_or_consts[def.local_id()]; + let resolver = def.parent().resolver(db.upcast()); + let ctx = TyLoweringContext::new(db, &resolver); + match data { + TypeOrConstParamData::TypeParamData(_) => { + never!(); + Ty::new(Interner, TyKind::Error) + } + TypeOrConstParamData::ConstParamData(d) => ctx.lower_ty(&d.ty), + } +} + +pub(crate) fn impl_self_ty_recover( + db: &dyn HirDatabase, + _cycle: &[String], + impl_id: &ImplId, +) -> Binders<Ty> { + let generics = generics(db.upcast(), (*impl_id).into()); + make_binders(db, &generics, TyKind::Error.intern(Interner)) +} + +pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> { + let impl_loc = impl_id.lookup(db.upcast()); + let impl_data = db.impl_data(impl_id); + let resolver = impl_id.resolver(db.upcast()); + let _cx = stdx::panic_context::enter(format!( + "impl_trait_query({:?} -> {:?} -> {:?})", + impl_id, impl_loc, impl_data + )); + let ctx = + TyLoweringContext::new(db, &resolver).with_type_param_mode(ParamLoweringMode::Variable); + let (self_ty, binders) = db.impl_self_ty(impl_id).into_value_and_skipped_binders(); + let target_trait = impl_data.target_trait.as_ref()?; + Some(Binders::new(binders, ctx.lower_trait_ref(target_trait, Some(self_ty))?)) +} + +pub(crate) fn return_type_impl_traits( + db: &dyn HirDatabase, + def: hir_def::FunctionId, +) -> Option<Arc<Binders<ReturnTypeImplTraits>>> { + // FIXME unify with fn_sig_for_fn instead of doing lowering twice, maybe + let data = db.function_data(def); + let resolver = def.resolver(db.upcast()); + let ctx_ret = TyLoweringContext::new(db, &resolver) + .with_impl_trait_mode(ImplTraitLoweringMode::Opaque) + .with_type_param_mode(ParamLoweringMode::Variable); + let _ret = (&ctx_ret).lower_ty(&data.ret_type); + let generics = generics(db.upcast(), def.into()); + let return_type_impl_traits = + ReturnTypeImplTraits { impl_traits: ctx_ret.opaque_type_data.into_inner() }; + if return_type_impl_traits.impl_traits.is_empty() { + None + } else { + Some(Arc::new(make_binders(db, &generics, return_type_impl_traits))) + } +} + +pub(crate) fn lower_to_chalk_mutability(m: hir_def::type_ref::Mutability) -> Mutability { + match m { + hir_def::type_ref::Mutability::Shared => Mutability::Not, + hir_def::type_ref::Mutability::Mut => Mutability::Mut, + } +} + +/// Checks if the provided generic arg matches its expected kind, then lower them via +/// provided closures. Use unknown if there was kind mismatch. +/// +/// Returns `Some` of the lowered generic arg. `None` if the provided arg is a lifetime. +pub(crate) fn generic_arg_to_chalk<'a, T>( + db: &dyn HirDatabase, + kind_id: Either<TypeParamId, ConstParamId>, + arg: &'a GenericArg, + this: &mut T, + for_type: impl FnOnce(&mut T, &TypeRef) -> Ty + 'a, + for_const: impl FnOnce(&mut T, &ConstScalarOrPath, Ty) -> Const + 'a, +) -> Option<crate::GenericArg> { + let kind = match kind_id { + Either::Left(_) => ParamKind::Type, + Either::Right(id) => { + let ty = db.const_param_ty(id); + ParamKind::Const(ty) + } + }; + Some(match (arg, kind) { + (GenericArg::Type(type_ref), ParamKind::Type) => { + let ty = for_type(this, type_ref); + GenericArgData::Ty(ty).intern(Interner) + } + (GenericArg::Const(c), ParamKind::Const(c_ty)) => { + GenericArgData::Const(for_const(this, c, c_ty)).intern(Interner) + } + (GenericArg::Const(_), ParamKind::Type) => { + GenericArgData::Ty(TyKind::Error.intern(Interner)).intern(Interner) + } + (GenericArg::Type(t), ParamKind::Const(c_ty)) => { + // We want to recover simple idents, which parser detects them + // as types. Maybe here is not the best place to do it, but + // it works. + if let TypeRef::Path(p) = t { + let p = p.mod_path(); + if p.kind == PathKind::Plain { + if let [n] = p.segments() { + let c = ConstScalarOrPath::Path(n.clone()); + return Some( + GenericArgData::Const(for_const(this, &c, c_ty)).intern(Interner), + ); + } + } + } + unknown_const_as_generic(c_ty) + } + (GenericArg::Lifetime(_), _) => return None, + }) +} + +pub(crate) fn const_or_path_to_chalk( + db: &dyn HirDatabase, + resolver: &Resolver, + expected_ty: Ty, + value: &ConstScalarOrPath, + mode: ParamLoweringMode, + args: impl FnOnce() -> Generics, + debruijn: DebruijnIndex, +) -> Const { + match value { + ConstScalarOrPath::Scalar(s) => intern_const_scalar(s.clone(), expected_ty), + ConstScalarOrPath::Path(n) => { + let path = ModPath::from_segments(PathKind::Plain, Some(n.clone())); + path_to_const(db, resolver, &path, mode, args, debruijn) + .unwrap_or_else(|| unknown_const(expected_ty)) + } + } +} + +/// This replaces any 'free' Bound vars in `s` (i.e. those with indices past +/// num_vars_to_keep) by `TyKind::Unknown`. +fn fallback_bound_vars<T: TypeFoldable<Interner> + HasInterner<Interner = Interner>>( + s: T, + num_vars_to_keep: usize, +) -> T { + crate::fold_free_vars( + s, + |bound, binders| { + if bound.index >= num_vars_to_keep && bound.debruijn == DebruijnIndex::INNERMOST { + TyKind::Error.intern(Interner) + } else { + bound.shifted_in_from(binders).to_ty(Interner) + } + }, + |ty, bound, binders| { + if bound.index >= num_vars_to_keep && bound.debruijn == DebruijnIndex::INNERMOST { + unknown_const(ty.clone()) + } else { + bound.shifted_in_from(binders).to_const(Interner, ty) + } + }, + ) +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs new file mode 100644 index 000000000..d765fee0e --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs @@ -0,0 +1,148 @@ +//! This module contains the implementations of the `ToChalk` trait, which +//! handles conversion between our data types and their corresponding types in +//! Chalk (in both directions); plus some helper functions for more specialized +//! conversions. + +use chalk_solve::rust_ir; + +use base_db::salsa::{self, InternKey}; +use hir_def::{LifetimeParamId, TraitId, TypeAliasId, TypeOrConstParamId}; + +use crate::{ + chalk_db, db::HirDatabase, AssocTypeId, CallableDefId, ChalkTraitId, FnDefId, ForeignDefId, + Interner, OpaqueTyId, PlaceholderIndex, +}; + +pub(crate) trait ToChalk { + type Chalk; + fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk; + fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self; +} + +pub(crate) fn from_chalk<T, ChalkT>(db: &dyn HirDatabase, chalk: ChalkT) -> T +where + T: ToChalk<Chalk = ChalkT>, +{ + T::from_chalk(db, chalk) +} + +impl ToChalk for hir_def::ImplId { + type Chalk = chalk_db::ImplId; + + fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::ImplId { + chalk_ir::ImplId(self.as_intern_id()) + } + + fn from_chalk(_db: &dyn HirDatabase, impl_id: chalk_db::ImplId) -> hir_def::ImplId { + InternKey::from_intern_id(impl_id.0) + } +} + +impl ToChalk for CallableDefId { + type Chalk = FnDefId; + + fn to_chalk(self, db: &dyn HirDatabase) -> FnDefId { + db.intern_callable_def(self).into() + } + + fn from_chalk(db: &dyn HirDatabase, fn_def_id: FnDefId) -> CallableDefId { + db.lookup_intern_callable_def(fn_def_id.into()) + } +} + +pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId); + +impl ToChalk for TypeAliasAsValue { + type Chalk = chalk_db::AssociatedTyValueId; + + fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::AssociatedTyValueId { + rust_ir::AssociatedTyValueId(self.0.as_intern_id()) + } + + fn from_chalk( + _db: &dyn HirDatabase, + assoc_ty_value_id: chalk_db::AssociatedTyValueId, + ) -> TypeAliasAsValue { + TypeAliasAsValue(TypeAliasId::from_intern_id(assoc_ty_value_id.0)) + } +} + +impl From<FnDefId> for crate::db::InternedCallableDefId { + fn from(fn_def_id: FnDefId) -> Self { + InternKey::from_intern_id(fn_def_id.0) + } +} + +impl From<crate::db::InternedCallableDefId> for FnDefId { + fn from(callable_def_id: crate::db::InternedCallableDefId) -> Self { + chalk_ir::FnDefId(callable_def_id.as_intern_id()) + } +} + +impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId { + fn from(id: OpaqueTyId) -> Self { + InternKey::from_intern_id(id.0) + } +} + +impl From<crate::db::InternedOpaqueTyId> for OpaqueTyId { + fn from(id: crate::db::InternedOpaqueTyId) -> Self { + chalk_ir::OpaqueTyId(id.as_intern_id()) + } +} + +impl From<chalk_ir::ClosureId<Interner>> for crate::db::InternedClosureId { + fn from(id: chalk_ir::ClosureId<Interner>) -> Self { + Self::from_intern_id(id.0) + } +} + +impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> { + fn from(id: crate::db::InternedClosureId) -> Self { + chalk_ir::ClosureId(id.as_intern_id()) + } +} + +pub fn to_foreign_def_id(id: TypeAliasId) -> ForeignDefId { + chalk_ir::ForeignDefId(salsa::InternKey::as_intern_id(&id)) +} + +pub fn from_foreign_def_id(id: ForeignDefId) -> TypeAliasId { + salsa::InternKey::from_intern_id(id.0) +} + +pub fn to_assoc_type_id(id: TypeAliasId) -> AssocTypeId { + chalk_ir::AssocTypeId(salsa::InternKey::as_intern_id(&id)) +} + +pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId { + salsa::InternKey::from_intern_id(id.0) +} + +pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeOrConstParamId { + assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT); + let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx)); + db.lookup_intern_type_or_const_param_id(interned_id) +} + +pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> PlaceholderIndex { + let interned_id = db.intern_type_or_const_param_id(id); + PlaceholderIndex { + ui: chalk_ir::UniverseIndex::ROOT, + idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(), + } +} + +pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId { + assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT); + let interned_id = salsa::InternKey::from_intern_id(salsa::InternId::from(idx.idx)); + db.lookup_intern_lifetime_param_id(interned_id) +} + +pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId { + chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id)) +} + +pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId { + salsa::InternKey::from_intern_id(id.0) +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs new file mode 100644 index 000000000..15df7b3dd --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs @@ -0,0 +1,1186 @@ +//! This module is concerned with finding methods that a given type provides. +//! For details about how this works in rustc, see the method lookup page in the +//! [rustc guide](https://rust-lang.github.io/rustc-guide/method-lookup.html) +//! and the corresponding code mostly in librustc_typeck/check/method/probe.rs. +use std::{iter, ops::ControlFlow, sync::Arc}; + +use arrayvec::ArrayVec; +use base_db::{CrateId, Edition}; +use chalk_ir::{cast::Cast, Mutability, UniverseIndex}; +use hir_def::{ + data::ImplData, item_scope::ItemScope, nameres::DefMap, AssocItemId, BlockId, ConstId, + FunctionId, GenericDefId, HasModule, ImplId, ItemContainerId, Lookup, ModuleDefId, ModuleId, + TraitId, +}; +use hir_expand::name::Name; +use rustc_hash::{FxHashMap, FxHashSet}; +use stdx::never; + +use crate::{ + autoderef::{self, AutoderefKind}, + db::HirDatabase, + from_foreign_def_id, + infer::{unify::InferenceTable, Adjust, Adjustment, AutoBorrow, OverloadedDeref, PointerCast}, + primitive::{FloatTy, IntTy, UintTy}, + static_lifetime, + utils::all_super_traits, + AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, InEnvironment, Interner, + Scalar, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, +}; + +/// This is used as a key for indexing impls. +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum TyFingerprint { + // These are lang item impls: + Str, + Slice, + Array, + Never, + RawPtr(Mutability), + Scalar(Scalar), + // These can have user-defined impls: + Adt(hir_def::AdtId), + Dyn(TraitId), + ForeignType(ForeignDefId), + // These only exist for trait impls + Unit, + Unnameable, + Function(u32), +} + +impl TyFingerprint { + /// Creates a TyFingerprint for looking up an inherent impl. Only certain + /// types can have inherent impls: if we have some `struct S`, we can have + /// an `impl S`, but not `impl &S`. Hence, this will return `None` for + /// reference types and such. + pub fn for_inherent_impl(ty: &Ty) -> Option<TyFingerprint> { + let fp = match ty.kind(Interner) { + TyKind::Str => TyFingerprint::Str, + TyKind::Never => TyFingerprint::Never, + TyKind::Slice(..) => TyFingerprint::Slice, + TyKind::Array(..) => TyFingerprint::Array, + TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar), + TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt), + TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability), + TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id), + TyKind::Dyn(_) => ty.dyn_trait().map(TyFingerprint::Dyn)?, + _ => return None, + }; + Some(fp) + } + + /// Creates a TyFingerprint for looking up a trait impl. + pub fn for_trait_impl(ty: &Ty) -> Option<TyFingerprint> { + let fp = match ty.kind(Interner) { + TyKind::Str => TyFingerprint::Str, + TyKind::Never => TyFingerprint::Never, + TyKind::Slice(..) => TyFingerprint::Slice, + TyKind::Array(..) => TyFingerprint::Array, + TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar), + TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt), + TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability), + TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id), + TyKind::Dyn(_) => ty.dyn_trait().map(TyFingerprint::Dyn)?, + TyKind::Ref(_, _, ty) => return TyFingerprint::for_trait_impl(ty), + TyKind::Tuple(_, subst) => { + let first_ty = subst.interned().get(0).map(|arg| arg.assert_ty_ref(Interner)); + match first_ty { + Some(ty) => return TyFingerprint::for_trait_impl(ty), + None => TyFingerprint::Unit, + } + } + TyKind::AssociatedType(_, _) + | TyKind::OpaqueType(_, _) + | TyKind::FnDef(_, _) + | TyKind::Closure(_, _) + | TyKind::Generator(..) + | TyKind::GeneratorWitness(..) => TyFingerprint::Unnameable, + TyKind::Function(fn_ptr) => { + TyFingerprint::Function(fn_ptr.substitution.0.len(Interner) as u32) + } + TyKind::Alias(_) + | TyKind::Placeholder(_) + | TyKind::BoundVar(_) + | TyKind::InferenceVar(_, _) + | TyKind::Error => return None, + }; + Some(fp) + } +} + +pub(crate) const ALL_INT_FPS: [TyFingerprint; 12] = [ + TyFingerprint::Scalar(Scalar::Int(IntTy::I8)), + TyFingerprint::Scalar(Scalar::Int(IntTy::I16)), + TyFingerprint::Scalar(Scalar::Int(IntTy::I32)), + TyFingerprint::Scalar(Scalar::Int(IntTy::I64)), + TyFingerprint::Scalar(Scalar::Int(IntTy::I128)), + TyFingerprint::Scalar(Scalar::Int(IntTy::Isize)), + TyFingerprint::Scalar(Scalar::Uint(UintTy::U8)), + TyFingerprint::Scalar(Scalar::Uint(UintTy::U16)), + TyFingerprint::Scalar(Scalar::Uint(UintTy::U32)), + TyFingerprint::Scalar(Scalar::Uint(UintTy::U64)), + TyFingerprint::Scalar(Scalar::Uint(UintTy::U128)), + TyFingerprint::Scalar(Scalar::Uint(UintTy::Usize)), +]; + +pub(crate) const ALL_FLOAT_FPS: [TyFingerprint; 2] = [ + TyFingerprint::Scalar(Scalar::Float(FloatTy::F32)), + TyFingerprint::Scalar(Scalar::Float(FloatTy::F64)), +]; + +/// Trait impls defined or available in some crate. +#[derive(Debug, Eq, PartialEq)] +pub struct TraitImpls { + // If the `Option<TyFingerprint>` is `None`, the impl may apply to any self type. + map: FxHashMap<TraitId, FxHashMap<Option<TyFingerprint>, Vec<ImplId>>>, +} + +impl TraitImpls { + pub(crate) fn trait_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> { + let _p = profile::span("trait_impls_in_crate_query").detail(|| format!("{krate:?}")); + let mut impls = Self { map: FxHashMap::default() }; + + let crate_def_map = db.crate_def_map(krate); + impls.collect_def_map(db, &crate_def_map); + impls.shrink_to_fit(); + + Arc::new(impls) + } + + pub(crate) fn trait_impls_in_block_query( + db: &dyn HirDatabase, + block: BlockId, + ) -> Option<Arc<Self>> { + let _p = profile::span("trait_impls_in_block_query"); + let mut impls = Self { map: FxHashMap::default() }; + + let block_def_map = db.block_def_map(block)?; + impls.collect_def_map(db, &block_def_map); + impls.shrink_to_fit(); + + Some(Arc::new(impls)) + } + + pub(crate) fn trait_impls_in_deps_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> { + let _p = profile::span("trait_impls_in_deps_query").detail(|| format!("{krate:?}")); + let crate_graph = db.crate_graph(); + let mut res = Self { map: FxHashMap::default() }; + + for krate in crate_graph.transitive_deps(krate) { + res.merge(&db.trait_impls_in_crate(krate)); + } + res.shrink_to_fit(); + + Arc::new(res) + } + + fn shrink_to_fit(&mut self) { + self.map.shrink_to_fit(); + self.map.values_mut().for_each(|map| { + map.shrink_to_fit(); + map.values_mut().for_each(Vec::shrink_to_fit); + }); + } + + fn collect_def_map(&mut self, db: &dyn HirDatabase, def_map: &DefMap) { + for (_module_id, module_data) in def_map.modules() { + for impl_id in module_data.scope.impls() { + let target_trait = match db.impl_trait(impl_id) { + Some(tr) => tr.skip_binders().hir_trait_id(), + None => continue, + }; + let self_ty = db.impl_self_ty(impl_id); + let self_ty_fp = TyFingerprint::for_trait_impl(self_ty.skip_binders()); + self.map + .entry(target_trait) + .or_default() + .entry(self_ty_fp) + .or_default() + .push(impl_id); + } + + // To better support custom derives, collect impls in all unnamed const items. + // const _: () = { ... }; + for konst in collect_unnamed_consts(db, &module_data.scope) { + let body = db.body(konst.into()); + for (_, block_def_map) in body.blocks(db.upcast()) { + self.collect_def_map(db, &block_def_map); + } + } + } + } + + fn merge(&mut self, other: &Self) { + for (trait_, other_map) in &other.map { + let map = self.map.entry(*trait_).or_default(); + for (fp, impls) in other_map { + map.entry(*fp).or_default().extend(impls); + } + } + } + + /// Queries all trait impls for the given type. + pub fn for_self_ty_without_blanket_impls( + &self, + fp: TyFingerprint, + ) -> impl Iterator<Item = ImplId> + '_ { + self.map + .values() + .flat_map(move |impls| impls.get(&Some(fp)).into_iter()) + .flat_map(|it| it.iter().copied()) + } + + /// Queries all impls of the given trait. + pub fn for_trait(&self, trait_: TraitId) -> impl Iterator<Item = ImplId> + '_ { + self.map + .get(&trait_) + .into_iter() + .flat_map(|map| map.values().flat_map(|v| v.iter().copied())) + } + + /// Queries all impls of `trait_` that may apply to `self_ty`. + pub fn for_trait_and_self_ty( + &self, + trait_: TraitId, + self_ty: TyFingerprint, + ) -> impl Iterator<Item = ImplId> + '_ { + self.map + .get(&trait_) + .into_iter() + .flat_map(move |map| map.get(&Some(self_ty)).into_iter().chain(map.get(&None))) + .flat_map(|v| v.iter().copied()) + } + + pub fn all_impls(&self) -> impl Iterator<Item = ImplId> + '_ { + self.map.values().flat_map(|map| map.values().flat_map(|v| v.iter().copied())) + } +} + +/// Inherent impls defined in some crate. +/// +/// Inherent impls can only be defined in the crate that also defines the self type of the impl +/// (note that some primitives are considered to be defined by both libcore and liballoc). +/// +/// This makes inherent impl lookup easier than trait impl lookup since we only have to consider a +/// single crate. +#[derive(Debug, Eq, PartialEq)] +pub struct InherentImpls { + map: FxHashMap<TyFingerprint, Vec<ImplId>>, +} + +impl InherentImpls { + pub(crate) fn inherent_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> { + let mut impls = Self { map: FxHashMap::default() }; + + let crate_def_map = db.crate_def_map(krate); + impls.collect_def_map(db, &crate_def_map); + impls.shrink_to_fit(); + + Arc::new(impls) + } + + pub(crate) fn inherent_impls_in_block_query( + db: &dyn HirDatabase, + block: BlockId, + ) -> Option<Arc<Self>> { + let mut impls = Self { map: FxHashMap::default() }; + if let Some(block_def_map) = db.block_def_map(block) { + impls.collect_def_map(db, &block_def_map); + impls.shrink_to_fit(); + return Some(Arc::new(impls)); + } + None + } + + fn shrink_to_fit(&mut self) { + self.map.values_mut().for_each(Vec::shrink_to_fit); + self.map.shrink_to_fit(); + } + + fn collect_def_map(&mut self, db: &dyn HirDatabase, def_map: &DefMap) { + for (_module_id, module_data) in def_map.modules() { + for impl_id in module_data.scope.impls() { + let data = db.impl_data(impl_id); + if data.target_trait.is_some() { + continue; + } + + let self_ty = db.impl_self_ty(impl_id); + let fp = TyFingerprint::for_inherent_impl(self_ty.skip_binders()); + if let Some(fp) = fp { + self.map.entry(fp).or_default().push(impl_id); + } + // `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution) + } + + // To better support custom derives, collect impls in all unnamed const items. + // const _: () = { ... }; + for konst in collect_unnamed_consts(db, &module_data.scope) { + let body = db.body(konst.into()); + for (_, block_def_map) in body.blocks(db.upcast()) { + self.collect_def_map(db, &block_def_map); + } + } + } + } + + pub fn for_self_ty(&self, self_ty: &Ty) -> &[ImplId] { + match TyFingerprint::for_inherent_impl(self_ty) { + Some(fp) => self.map.get(&fp).map(|vec| vec.as_ref()).unwrap_or(&[]), + None => &[], + } + } + + pub fn all_impls(&self) -> impl Iterator<Item = ImplId> + '_ { + self.map.values().flat_map(|v| v.iter().copied()) + } +} + +pub fn inherent_impl_crates_query( + db: &dyn HirDatabase, + krate: CrateId, + fp: TyFingerprint, +) -> ArrayVec<CrateId, 2> { + let _p = profile::span("inherent_impl_crates_query"); + let mut res = ArrayVec::new(); + let crate_graph = db.crate_graph(); + + for krate in crate_graph.transitive_deps(krate) { + if res.is_full() { + // we don't currently look for or store more than two crates here, + // so don't needlessly look at more crates than necessary. + break; + } + let impls = db.inherent_impls_in_crate(krate); + if impls.map.get(&fp).map_or(false, |v| !v.is_empty()) { + res.push(krate); + } + } + + res +} + +fn collect_unnamed_consts<'a>( + db: &'a dyn HirDatabase, + scope: &'a ItemScope, +) -> impl Iterator<Item = ConstId> + 'a { + let unnamed_consts = scope.unnamed_consts(); + + // FIXME: Also treat consts named `_DERIVE_*` as unnamed, since synstructure generates those. + // Should be removed once synstructure stops doing that. + let synstructure_hack_consts = scope.values().filter_map(|(item, _)| match item { + ModuleDefId::ConstId(id) => { + let loc = id.lookup(db.upcast()); + let item_tree = loc.id.item_tree(db.upcast()); + if item_tree[loc.id.value] + .name + .as_ref() + .map_or(false, |n| n.to_smol_str().starts_with("_DERIVE_")) + { + Some(id) + } else { + None + } + } + _ => None, + }); + + unnamed_consts.chain(synstructure_hack_consts) +} + +pub fn def_crates( + db: &dyn HirDatabase, + ty: &Ty, + cur_crate: CrateId, +) -> Option<ArrayVec<CrateId, 2>> { + let mod_to_crate_ids = |module: ModuleId| Some(iter::once(module.krate()).collect()); + + let fp = TyFingerprint::for_inherent_impl(ty); + + match ty.kind(Interner) { + TyKind::Adt(AdtId(def_id), _) => mod_to_crate_ids(def_id.module(db.upcast())), + TyKind::Foreign(id) => { + mod_to_crate_ids(from_foreign_def_id(*id).lookup(db.upcast()).module(db.upcast())) + } + TyKind::Dyn(_) => ty + .dyn_trait() + .and_then(|trait_| mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast()))), + // for primitives, there may be impls in various places (core and alloc + // mostly). We just check the whole crate graph for crates with impls + // (cached behind a query). + TyKind::Scalar(_) + | TyKind::Str + | TyKind::Slice(_) + | TyKind::Array(..) + | TyKind::Raw(..) => { + Some(db.inherent_impl_crates(cur_crate, fp.expect("fingerprint for primitive"))) + } + _ => return None, + } +} + +/// Look up the method with the given name. +pub(crate) fn lookup_method( + ty: &Canonical<Ty>, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + traits_in_scope: &FxHashSet<TraitId>, + visible_from_module: VisibleFromModule, + name: &Name, +) -> Option<(ReceiverAdjustments, FunctionId)> { + iterate_method_candidates( + ty, + db, + env, + traits_in_scope, + visible_from_module, + Some(name), + LookupMode::MethodCall, + |adjustments, f| match f { + AssocItemId::FunctionId(f) => Some((adjustments, f)), + _ => None, + }, + ) +} + +/// Whether we're looking up a dotted method call (like `v.len()`) or a path +/// (like `Vec::new`). +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum LookupMode { + /// Looking up a method call like `v.len()`: We only consider candidates + /// that have a `self` parameter, and do autoderef. + MethodCall, + /// Looking up a path like `Vec::new` or `Vec::default`: We consider all + /// candidates including associated constants, but don't do autoderef. + Path, +} + +#[derive(Clone, Copy)] +pub enum VisibleFromModule { + /// Filter for results that are visible from the given module + Filter(ModuleId), + /// Include impls from the given block. + IncludeBlock(BlockId), + /// Do nothing special in regards visibility + None, +} + +impl From<Option<ModuleId>> for VisibleFromModule { + fn from(module: Option<ModuleId>) -> Self { + match module { + Some(module) => Self::Filter(module), + None => Self::None, + } + } +} + +impl From<Option<BlockId>> for VisibleFromModule { + fn from(block: Option<BlockId>) -> Self { + match block { + Some(block) => Self::IncludeBlock(block), + None => Self::None, + } + } +} + +#[derive(Debug, Clone, Default)] +pub struct ReceiverAdjustments { + autoref: Option<Mutability>, + autoderefs: usize, + unsize_array: bool, +} + +impl ReceiverAdjustments { + pub(crate) fn apply(&self, table: &mut InferenceTable<'_>, ty: Ty) -> (Ty, Vec<Adjustment>) { + let mut ty = ty; + let mut adjust = Vec::new(); + for _ in 0..self.autoderefs { + match autoderef::autoderef_step(table, ty.clone()) { + None => { + never!("autoderef not possible for {:?}", ty); + ty = TyKind::Error.intern(Interner); + break; + } + Some((kind, new_ty)) => { + ty = new_ty.clone(); + adjust.push(Adjustment { + kind: Adjust::Deref(match kind { + // FIXME should we know the mutability here? + AutoderefKind::Overloaded => Some(OverloadedDeref(Mutability::Not)), + AutoderefKind::Builtin => None, + }), + target: new_ty, + }); + } + } + } + if self.unsize_array { + ty = match ty.kind(Interner) { + TyKind::Array(inner, _) => TyKind::Slice(inner.clone()).intern(Interner), + _ => { + never!("unsize_array with non-array {:?}", ty); + ty + } + }; + // FIXME this is kind of wrong since the unsize needs to happen to a pointer/reference + adjust.push(Adjustment { + kind: Adjust::Pointer(PointerCast::Unsize), + target: ty.clone(), + }); + } + if let Some(m) = self.autoref { + ty = TyKind::Ref(m, static_lifetime(), ty).intern(Interner); + adjust + .push(Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(m)), target: ty.clone() }); + } + (ty, adjust) + } + + fn with_autoref(&self, m: Mutability) -> ReceiverAdjustments { + Self { autoref: Some(m), ..*self } + } +} + +// This would be nicer if it just returned an iterator, but that runs into +// lifetime problems, because we need to borrow temp `CrateImplDefs`. +// FIXME add a context type here? +pub(crate) fn iterate_method_candidates<T>( + ty: &Canonical<Ty>, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + traits_in_scope: &FxHashSet<TraitId>, + visible_from_module: VisibleFromModule, + name: Option<&Name>, + mode: LookupMode, + mut callback: impl FnMut(ReceiverAdjustments, AssocItemId) -> Option<T>, +) -> Option<T> { + let mut slot = None; + iterate_method_candidates_dyn( + ty, + db, + env, + traits_in_scope, + visible_from_module, + name, + mode, + &mut |adj, item| { + assert!(slot.is_none()); + if let Some(it) = callback(adj, item) { + slot = Some(it); + return ControlFlow::Break(()); + } + ControlFlow::Continue(()) + }, + ); + slot +} + +pub fn lookup_impl_method( + self_ty: &Ty, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + trait_: TraitId, + name: &Name, +) -> Option<FunctionId> { + let self_ty_fp = TyFingerprint::for_trait_impl(self_ty)?; + let trait_impls = db.trait_impls_in_deps(env.krate); + let impls = trait_impls.for_trait_and_self_ty(trait_, self_ty_fp); + let mut table = InferenceTable::new(db, env.clone()); + find_matching_impl(impls, &mut table, &self_ty).and_then(|data| { + data.items.iter().find_map(|it| match it { + AssocItemId::FunctionId(f) => (db.function_data(*f).name == *name).then(|| *f), + _ => None, + }) + }) +} + +fn find_matching_impl( + mut impls: impl Iterator<Item = ImplId>, + table: &mut InferenceTable<'_>, + self_ty: &Ty, +) -> Option<Arc<ImplData>> { + let db = table.db; + loop { + let impl_ = impls.next()?; + let r = table.run_in_snapshot(|table| { + let impl_data = db.impl_data(impl_); + let substs = + TyBuilder::subst_for_def(db, impl_).fill_with_inference_vars(table).build(); + let impl_ty = db.impl_self_ty(impl_).substitute(Interner, &substs); + + table + .unify(self_ty, &impl_ty) + .then(|| { + let wh_goals = + crate::chalk_db::convert_where_clauses(db, impl_.into(), &substs) + .into_iter() + .map(|b| b.cast(Interner)); + + let goal = crate::Goal::all(Interner, wh_goals); + + table.try_obligation(goal).map(|_| impl_data) + }) + .flatten() + }); + if r.is_some() { + break r; + } + } +} + +pub fn iterate_path_candidates( + ty: &Canonical<Ty>, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + traits_in_scope: &FxHashSet<TraitId>, + visible_from_module: VisibleFromModule, + name: Option<&Name>, + callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>, +) -> ControlFlow<()> { + iterate_method_candidates_dyn( + ty, + db, + env, + traits_in_scope, + visible_from_module, + name, + LookupMode::Path, + // the adjustments are not relevant for path lookup + &mut |_, id| callback(id), + ) +} + +pub fn iterate_method_candidates_dyn( + ty: &Canonical<Ty>, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + traits_in_scope: &FxHashSet<TraitId>, + visible_from_module: VisibleFromModule, + name: Option<&Name>, + mode: LookupMode, + callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId) -> ControlFlow<()>, +) -> ControlFlow<()> { + match mode { + LookupMode::MethodCall => { + // For method calls, rust first does any number of autoderef, and + // then one autoref (i.e. when the method takes &self or &mut self). + // Note that when we've got a receiver like &S, even if the method + // we find in the end takes &self, we still do the autoderef step + // (just as rustc does an autoderef and then autoref again). + + // We have to be careful about the order we're looking at candidates + // in here. Consider the case where we're resolving `x.clone()` + // where `x: &Vec<_>`. This resolves to the clone method with self + // type `Vec<_>`, *not* `&_`. I.e. we need to consider methods where + // the receiver type exactly matches before cases where we have to + // do autoref. But in the autoderef steps, the `&_` self type comes + // up *before* the `Vec<_>` self type. + // + // On the other hand, we don't want to just pick any by-value method + // before any by-autoref method; it's just that we need to consider + // the methods by autoderef order of *receiver types*, not *self + // types*. + + let mut table = InferenceTable::new(db, env.clone()); + let ty = table.instantiate_canonical(ty.clone()); + let (deref_chain, adj) = autoderef_method_receiver(&mut table, ty); + + let result = deref_chain.into_iter().zip(adj).try_for_each(|(receiver_ty, adj)| { + iterate_method_candidates_with_autoref( + &receiver_ty, + adj, + db, + env.clone(), + traits_in_scope, + visible_from_module, + name, + callback, + ) + }); + result + } + LookupMode::Path => { + // No autoderef for path lookups + iterate_method_candidates_for_self_ty( + ty, + db, + env, + traits_in_scope, + visible_from_module, + name, + callback, + ) + } + } +} + +fn iterate_method_candidates_with_autoref( + receiver_ty: &Canonical<Ty>, + first_adjustment: ReceiverAdjustments, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + traits_in_scope: &FxHashSet<TraitId>, + visible_from_module: VisibleFromModule, + name: Option<&Name>, + mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId) -> ControlFlow<()>, +) -> ControlFlow<()> { + if receiver_ty.value.is_general_var(Interner, &receiver_ty.binders) { + // don't try to resolve methods on unknown types + return ControlFlow::Continue(()); + } + + iterate_method_candidates_by_receiver( + receiver_ty, + first_adjustment.clone(), + db, + env.clone(), + traits_in_scope, + visible_from_module, + name, + &mut callback, + )?; + + let refed = Canonical { + value: TyKind::Ref(Mutability::Not, static_lifetime(), receiver_ty.value.clone()) + .intern(Interner), + binders: receiver_ty.binders.clone(), + }; + + iterate_method_candidates_by_receiver( + &refed, + first_adjustment.with_autoref(Mutability::Not), + db, + env.clone(), + traits_in_scope, + visible_from_module, + name, + &mut callback, + )?; + + let ref_muted = Canonical { + value: TyKind::Ref(Mutability::Mut, static_lifetime(), receiver_ty.value.clone()) + .intern(Interner), + binders: receiver_ty.binders.clone(), + }; + + iterate_method_candidates_by_receiver( + &ref_muted, + first_adjustment.with_autoref(Mutability::Mut), + db, + env, + traits_in_scope, + visible_from_module, + name, + &mut callback, + ) +} + +fn iterate_method_candidates_by_receiver( + receiver_ty: &Canonical<Ty>, + receiver_adjustments: ReceiverAdjustments, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + traits_in_scope: &FxHashSet<TraitId>, + visible_from_module: VisibleFromModule, + name: Option<&Name>, + mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId) -> ControlFlow<()>, +) -> ControlFlow<()> { + let mut table = InferenceTable::new(db, env); + let receiver_ty = table.instantiate_canonical(receiver_ty.clone()); + let snapshot = table.snapshot(); + // We're looking for methods with *receiver* type receiver_ty. These could + // be found in any of the derefs of receiver_ty, so we have to go through + // that. + let mut autoderef = autoderef::Autoderef::new(&mut table, receiver_ty.clone()); + while let Some((self_ty, _)) = autoderef.next() { + iterate_inherent_methods( + &self_ty, + &mut autoderef.table, + name, + Some(&receiver_ty), + Some(receiver_adjustments.clone()), + visible_from_module, + &mut callback, + )? + } + + table.rollback_to(snapshot); + + let mut autoderef = autoderef::Autoderef::new(&mut table, receiver_ty.clone()); + while let Some((self_ty, _)) = autoderef.next() { + iterate_trait_method_candidates( + &self_ty, + &mut autoderef.table, + traits_in_scope, + name, + Some(&receiver_ty), + Some(receiver_adjustments.clone()), + &mut callback, + )? + } + + ControlFlow::Continue(()) +} + +fn iterate_method_candidates_for_self_ty( + self_ty: &Canonical<Ty>, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + traits_in_scope: &FxHashSet<TraitId>, + visible_from_module: VisibleFromModule, + name: Option<&Name>, + mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId) -> ControlFlow<()>, +) -> ControlFlow<()> { + let mut table = InferenceTable::new(db, env); + let self_ty = table.instantiate_canonical(self_ty.clone()); + iterate_inherent_methods( + &self_ty, + &mut table, + name, + None, + None, + visible_from_module, + &mut callback, + )?; + iterate_trait_method_candidates( + &self_ty, + &mut table, + traits_in_scope, + name, + None, + None, + callback, + ) +} + +fn iterate_trait_method_candidates( + self_ty: &Ty, + table: &mut InferenceTable<'_>, + traits_in_scope: &FxHashSet<TraitId>, + name: Option<&Name>, + receiver_ty: Option<&Ty>, + receiver_adjustments: Option<ReceiverAdjustments>, + callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId) -> ControlFlow<()>, +) -> ControlFlow<()> { + let db = table.db; + let env = table.trait_env.clone(); + let self_is_array = matches!(self_ty.kind(Interner), chalk_ir::TyKind::Array(..)); + // if ty is `dyn Trait`, the trait doesn't need to be in scope + let inherent_trait = + self_ty.dyn_trait().into_iter().flat_map(|t| all_super_traits(db.upcast(), t)); + let env_traits = matches!(self_ty.kind(Interner), TyKind::Placeholder(_)) + // if we have `T: Trait` in the param env, the trait doesn't need to be in scope + .then(|| { + env.traits_in_scope_from_clauses(self_ty.clone()) + .flat_map(|t| all_super_traits(db.upcast(), t)) + }) + .into_iter() + .flatten(); + let traits = inherent_trait.chain(env_traits).chain(traits_in_scope.iter().copied()); + + let canonical_self_ty = table.canonicalize(self_ty.clone()).value; + + 'traits: for t in traits { + let data = db.trait_data(t); + + // Traits annotated with `#[rustc_skip_array_during_method_dispatch]` are skipped during + // method resolution, if the receiver is an array, and we're compiling for editions before + // 2021. + // This is to make `[a].into_iter()` not break code with the new `IntoIterator` impl for + // arrays. + if data.skip_array_during_method_dispatch && self_is_array { + // FIXME: this should really be using the edition of the method name's span, in case it + // comes from a macro + if db.crate_graph()[env.krate].edition < Edition::Edition2021 { + continue; + } + } + + // we'll be lazy about checking whether the type implements the + // trait, but if we find out it doesn't, we'll skip the rest of the + // iteration + let mut known_implemented = false; + for &(_, item) in data.items.iter() { + // Don't pass a `visible_from_module` down to `is_valid_candidate`, + // since only inherent methods should be included into visibility checking. + if !is_valid_candidate(table, name, receiver_ty, item, self_ty, None) { + continue; + } + if !known_implemented { + let goal = generic_implements_goal(db, env.clone(), t, &canonical_self_ty); + if db.trait_solve(env.krate, goal.cast(Interner)).is_none() { + continue 'traits; + } + } + known_implemented = true; + callback(receiver_adjustments.clone().unwrap_or_default(), item)?; + } + } + ControlFlow::Continue(()) +} + +fn iterate_inherent_methods( + self_ty: &Ty, + table: &mut InferenceTable<'_>, + name: Option<&Name>, + receiver_ty: Option<&Ty>, + receiver_adjustments: Option<ReceiverAdjustments>, + visible_from_module: VisibleFromModule, + callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId) -> ControlFlow<()>, +) -> ControlFlow<()> { + let db = table.db; + let env = table.trait_env.clone(); + let def_crates = match def_crates(db, self_ty, env.krate) { + Some(k) => k, + None => return ControlFlow::Continue(()), + }; + + let (module, block) = match visible_from_module { + VisibleFromModule::Filter(module) => (Some(module), module.containing_block()), + VisibleFromModule::IncludeBlock(block) => (None, Some(block)), + VisibleFromModule::None => (None, None), + }; + + if let Some(block_id) = block { + if let Some(impls) = db.inherent_impls_in_block(block_id) { + impls_for_self_ty( + &impls, + self_ty, + table, + name, + receiver_ty, + receiver_adjustments.clone(), + module, + callback, + )?; + } + } + + for krate in def_crates { + let impls = db.inherent_impls_in_crate(krate); + impls_for_self_ty( + &impls, + self_ty, + table, + name, + receiver_ty, + receiver_adjustments.clone(), + module, + callback, + )?; + } + return ControlFlow::Continue(()); + + fn impls_for_self_ty( + impls: &InherentImpls, + self_ty: &Ty, + table: &mut InferenceTable<'_>, + name: Option<&Name>, + receiver_ty: Option<&Ty>, + receiver_adjustments: Option<ReceiverAdjustments>, + visible_from_module: Option<ModuleId>, + callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId) -> ControlFlow<()>, + ) -> ControlFlow<()> { + let db = table.db; + let impls_for_self_ty = impls.for_self_ty(self_ty); + for &impl_def in impls_for_self_ty { + for &item in &db.impl_data(impl_def).items { + if !is_valid_candidate(table, name, receiver_ty, item, self_ty, visible_from_module) + { + continue; + } + callback(receiver_adjustments.clone().unwrap_or_default(), item)?; + } + } + ControlFlow::Continue(()) + } +} + +/// Returns the receiver type for the index trait call. +pub fn resolve_indexing_op( + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + ty: Canonical<Ty>, + index_trait: TraitId, +) -> Option<ReceiverAdjustments> { + let mut table = InferenceTable::new(db, env.clone()); + let ty = table.instantiate_canonical(ty); + let (deref_chain, adj) = autoderef_method_receiver(&mut table, ty); + for (ty, adj) in deref_chain.into_iter().zip(adj) { + let goal = generic_implements_goal(db, env.clone(), index_trait, &ty); + if db.trait_solve(env.krate, goal.cast(Interner)).is_some() { + return Some(adj); + } + } + None +} + +fn is_valid_candidate( + table: &mut InferenceTable<'_>, + name: Option<&Name>, + receiver_ty: Option<&Ty>, + item: AssocItemId, + self_ty: &Ty, + visible_from_module: Option<ModuleId>, +) -> bool { + macro_rules! check_that { + ($cond:expr) => { + if !$cond { + return false; + } + }; + } + + let db = table.db; + match item { + AssocItemId::FunctionId(m) => { + let data = db.function_data(m); + + check_that!(name.map_or(true, |n| n == &data.name)); + check_that!(visible_from_module.map_or(true, |from_module| { + let v = db.function_visibility(m).is_visible_from(db.upcast(), from_module); + if !v { + cov_mark::hit!(autoderef_candidate_not_visible); + } + v + })); + + table.run_in_snapshot(|table| { + let subst = TyBuilder::subst_for_def(db, m).fill_with_inference_vars(table).build(); + let expect_self_ty = match m.lookup(db.upcast()).container { + ItemContainerId::TraitId(_) => { + subst.at(Interner, 0).assert_ty_ref(Interner).clone() + } + ItemContainerId::ImplId(impl_id) => { + subst.apply(db.impl_self_ty(impl_id).skip_binders().clone(), Interner) + } + // We should only get called for associated items (impl/trait) + ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => { + unreachable!() + } + }; + check_that!(table.unify(&expect_self_ty, self_ty)); + if let Some(receiver_ty) = receiver_ty { + check_that!(data.has_self_param()); + + let sig = db.callable_item_signature(m.into()); + let expected_receiver = + sig.map(|s| s.params()[0].clone()).substitute(Interner, &subst); + + check_that!(table.unify(&receiver_ty, &expected_receiver)); + } + true + }) + } + AssocItemId::ConstId(c) => { + let data = db.const_data(c); + check_that!(receiver_ty.is_none()); + + check_that!(name.map_or(true, |n| data.name.as_ref() == Some(n))); + check_that!(visible_from_module.map_or(true, |from_module| { + let v = db.const_visibility(c).is_visible_from(db.upcast(), from_module); + if !v { + cov_mark::hit!(const_candidate_not_visible); + } + v + })); + if let ItemContainerId::ImplId(impl_id) = c.lookup(db.upcast()).container { + let self_ty_matches = table.run_in_snapshot(|table| { + let subst = + TyBuilder::subst_for_def(db, c).fill_with_inference_vars(table).build(); + let expected_self_ty = + subst.apply(db.impl_self_ty(impl_id).skip_binders().clone(), Interner); + table.unify(&expected_self_ty, &self_ty) + }); + if !self_ty_matches { + cov_mark::hit!(const_candidate_self_type_mismatch); + return false; + } + } + true + } + _ => false, + } +} + +pub fn implements_trait( + ty: &Canonical<Ty>, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + trait_: TraitId, +) -> bool { + let goal = generic_implements_goal(db, env.clone(), trait_, ty); + let solution = db.trait_solve(env.krate, goal.cast(Interner)); + + solution.is_some() +} + +pub fn implements_trait_unique( + ty: &Canonical<Ty>, + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + trait_: TraitId, +) -> bool { + let goal = generic_implements_goal(db, env.clone(), trait_, ty); + let solution = db.trait_solve(env.krate, goal.cast(Interner)); + + matches!(solution, Some(crate::Solution::Unique(_))) +} + +/// This creates Substs for a trait with the given Self type and type variables +/// for all other parameters, to query Chalk with it. +fn generic_implements_goal( + db: &dyn HirDatabase, + env: Arc<TraitEnvironment>, + trait_: TraitId, + self_ty: &Canonical<Ty>, +) -> Canonical<InEnvironment<super::DomainGoal>> { + let mut kinds = self_ty.binders.interned().to_vec(); + let trait_ref = TyBuilder::trait_ref(db, trait_) + .push(self_ty.value.clone()) + .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len()) + .build(); + kinds.extend(trait_ref.substitution.iter(Interner).skip(1).map(|x| { + let vk = match x.data(Interner) { + chalk_ir::GenericArgData::Ty(_) => { + chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General) + } + chalk_ir::GenericArgData::Lifetime(_) => chalk_ir::VariableKind::Lifetime, + chalk_ir::GenericArgData::Const(c) => { + chalk_ir::VariableKind::Const(c.data(Interner).ty.clone()) + } + }; + chalk_ir::WithKind::new(vk, UniverseIndex::ROOT) + })); + let obligation = trait_ref.cast(Interner); + Canonical { + binders: CanonicalVarKinds::from_iter(Interner, kinds), + value: InEnvironment::new(&env.env, obligation), + } +} + +fn autoderef_method_receiver( + table: &mut InferenceTable<'_>, + ty: Ty, +) -> (Vec<Canonical<Ty>>, Vec<ReceiverAdjustments>) { + let (mut deref_chain, mut adjustments): (Vec<_>, Vec<_>) = (Vec::new(), Vec::new()); + let mut autoderef = autoderef::Autoderef::new(table, ty); + while let Some((ty, derefs)) = autoderef.next() { + deref_chain.push(autoderef.table.canonicalize(ty).value); + adjustments.push(ReceiverAdjustments { + autoref: None, + autoderefs: derefs, + unsize_array: false, + }); + } + // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!) + if let (Some((TyKind::Array(parameters, _), binders)), Some(adj)) = ( + deref_chain.last().map(|ty| (ty.value.kind(Interner), ty.binders.clone())), + adjustments.last().cloned(), + ) { + let unsized_ty = TyKind::Slice(parameters.clone()).intern(Interner); + deref_chain.push(Canonical { value: unsized_ty, binders }); + adjustments.push(ReceiverAdjustments { unsize_array: true, ..adj }); + } + (deref_chain, adjustments) +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/primitive.rs b/src/tools/rust-analyzer/crates/hir-ty/src/primitive.rs new file mode 100644 index 000000000..d7f48c69a --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/primitive.rs @@ -0,0 +1,62 @@ +//! A few helper functions for dealing with primitives. + +pub use chalk_ir::{FloatTy, IntTy, UintTy}; +pub use hir_def::builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint}; + +pub fn int_ty_to_string(ty: IntTy) -> &'static str { + match ty { + IntTy::Isize => "isize", + IntTy::I8 => "i8", + IntTy::I16 => "i16", + IntTy::I32 => "i32", + IntTy::I64 => "i64", + IntTy::I128 => "i128", + } +} + +pub fn uint_ty_to_string(ty: UintTy) -> &'static str { + match ty { + UintTy::Usize => "usize", + UintTy::U8 => "u8", + UintTy::U16 => "u16", + UintTy::U32 => "u32", + UintTy::U64 => "u64", + UintTy::U128 => "u128", + } +} + +pub fn float_ty_to_string(ty: FloatTy) -> &'static str { + match ty { + FloatTy::F32 => "f32", + FloatTy::F64 => "f64", + } +} + +pub(super) fn int_ty_from_builtin(t: BuiltinInt) -> IntTy { + match t { + BuiltinInt::Isize => IntTy::Isize, + BuiltinInt::I8 => IntTy::I8, + BuiltinInt::I16 => IntTy::I16, + BuiltinInt::I32 => IntTy::I32, + BuiltinInt::I64 => IntTy::I64, + BuiltinInt::I128 => IntTy::I128, + } +} + +pub(super) fn uint_ty_from_builtin(t: BuiltinUint) -> UintTy { + match t { + BuiltinUint::Usize => UintTy::Usize, + BuiltinUint::U8 => UintTy::U8, + BuiltinUint::U16 => UintTy::U16, + BuiltinUint::U32 => UintTy::U32, + BuiltinUint::U64 => UintTy::U64, + BuiltinUint::U128 => UintTy::U128, + } +} + +pub(super) fn float_ty_from_builtin(t: BuiltinFloat) -> FloatTy { + match t { + BuiltinFloat::F32 => FloatTy::F32, + BuiltinFloat::F64 => FloatTy::F64, + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/test_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/test_db.rs new file mode 100644 index 000000000..dc7252f70 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/test_db.rs @@ -0,0 +1,150 @@ +//! Database used for testing `hir`. + +use std::{ + fmt, panic, + sync::{Arc, Mutex}, +}; + +use base_db::{ + salsa, AnchoredPath, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase, Upcast, +}; +use hir_def::{db::DefDatabase, ModuleId}; +use hir_expand::db::AstDatabase; +use rustc_hash::{FxHashMap, FxHashSet}; +use syntax::TextRange; +use test_utils::extract_annotations; + +#[salsa::database( + base_db::SourceDatabaseExtStorage, + base_db::SourceDatabaseStorage, + hir_expand::db::AstDatabaseStorage, + hir_def::db::InternDatabaseStorage, + hir_def::db::DefDatabaseStorage, + crate::db::HirDatabaseStorage +)] +pub(crate) struct TestDB { + storage: salsa::Storage<TestDB>, + events: Mutex<Option<Vec<salsa::Event>>>, +} + +impl Default for TestDB { + fn default() -> Self { + let mut this = Self { storage: Default::default(), events: Default::default() }; + this.set_enable_proc_attr_macros(true); + this + } +} + +impl fmt::Debug for TestDB { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("TestDB").finish() + } +} + +impl Upcast<dyn AstDatabase> for TestDB { + fn upcast(&self) -> &(dyn AstDatabase + 'static) { + &*self + } +} + +impl Upcast<dyn DefDatabase> for TestDB { + fn upcast(&self) -> &(dyn DefDatabase + 'static) { + &*self + } +} + +impl salsa::Database for TestDB { + fn salsa_event(&self, event: salsa::Event) { + let mut events = self.events.lock().unwrap(); + if let Some(events) = &mut *events { + events.push(event); + } + } +} + +impl salsa::ParallelDatabase for TestDB { + fn snapshot(&self) -> salsa::Snapshot<TestDB> { + salsa::Snapshot::new(TestDB { + storage: self.storage.snapshot(), + events: Default::default(), + }) + } +} + +impl panic::RefUnwindSafe for TestDB {} + +impl FileLoader for TestDB { + fn file_text(&self, file_id: FileId) -> Arc<String> { + FileLoaderDelegate(self).file_text(file_id) + } + fn resolve_path(&self, path: AnchoredPath<'_>) -> Option<FileId> { + FileLoaderDelegate(self).resolve_path(path) + } + fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> { + FileLoaderDelegate(self).relevant_crates(file_id) + } +} + +impl TestDB { + pub(crate) fn module_for_file_opt(&self, file_id: FileId) -> Option<ModuleId> { + for &krate in self.relevant_crates(file_id).iter() { + let crate_def_map = self.crate_def_map(krate); + for (local_id, data) in crate_def_map.modules() { + if data.origin.file_id() == Some(file_id) { + return Some(crate_def_map.module_id(local_id)); + } + } + } + None + } + + pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId { + self.module_for_file_opt(file_id).unwrap() + } + + pub(crate) fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> { + let mut files = Vec::new(); + let crate_graph = self.crate_graph(); + for krate in crate_graph.iter() { + let crate_def_map = self.crate_def_map(krate); + for (module_id, _) in crate_def_map.modules() { + let file_id = crate_def_map[module_id].origin.file_id(); + files.extend(file_id) + } + } + files + .into_iter() + .filter_map(|file_id| { + let text = self.file_text(file_id); + let annotations = extract_annotations(&text); + if annotations.is_empty() { + return None; + } + Some((file_id, annotations)) + }) + .collect() + } +} + +impl TestDB { + pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> { + *self.events.lock().unwrap() = Some(Vec::new()); + f(); + self.events.lock().unwrap().take().unwrap() + } + + pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> { + let events = self.log(f); + events + .into_iter() + .filter_map(|e| match e.kind { + // This is pretty horrible, but `Debug` is the only way to inspect + // QueryDescriptor at the moment. + salsa::EventKind::WillExecute { database_key } => { + Some(format!("{:?}", database_key.debug(self))) + } + _ => None, + }) + .collect() + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs new file mode 100644 index 000000000..d2f13e435 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs @@ -0,0 +1,578 @@ +mod never_type; +mod coercion; +mod regression; +mod simple; +mod patterns; +mod traits; +mod method_resolution; +mod macros; +mod display_source_code; +mod incremental; +mod diagnostics; + +use std::{collections::HashMap, env, sync::Arc}; + +use base_db::{fixture::WithFixture, FileRange, SourceDatabaseExt}; +use expect_test::Expect; +use hir_def::{ + body::{Body, BodySourceMap, SyntheticSyntax}, + db::DefDatabase, + expr::{ExprId, PatId}, + item_scope::ItemScope, + nameres::DefMap, + src::HasSource, + AssocItemId, DefWithBodyId, HasModule, LocalModuleId, Lookup, ModuleDefId, +}; +use hir_expand::{db::AstDatabase, InFile}; +use once_cell::race::OnceBool; +use stdx::format_to; +use syntax::{ + ast::{self, AstNode, HasName}, + SyntaxNode, +}; +use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Registry}; +use tracing_tree::HierarchicalLayer; + +use crate::{ + db::HirDatabase, + display::HirDisplay, + infer::{Adjustment, TypeMismatch}, + test_db::TestDB, + InferenceResult, Ty, +}; + +// These tests compare the inference results for all expressions in a file +// against snapshots of the expected results using expect. Use +// `env UPDATE_EXPECT=1 cargo test -p hir_ty` to update the snapshots. + +fn setup_tracing() -> Option<tracing::subscriber::DefaultGuard> { + static ENABLE: OnceBool = OnceBool::new(); + if !ENABLE.get_or_init(|| env::var("CHALK_DEBUG").is_ok()) { + return None; + } + + let filter = EnvFilter::from_env("CHALK_DEBUG"); + let layer = HierarchicalLayer::default() + .with_indent_lines(true) + .with_ansi(false) + .with_indent_amount(2) + .with_writer(std::io::stderr); + let subscriber = Registry::default().with(filter).with(layer); + Some(tracing::subscriber::set_default(subscriber)) +} + +fn check_types(ra_fixture: &str) { + check_impl(ra_fixture, false, true, false) +} + +fn check_types_source_code(ra_fixture: &str) { + check_impl(ra_fixture, false, true, true) +} + +fn check_no_mismatches(ra_fixture: &str) { + check_impl(ra_fixture, true, false, false) +} + +fn check(ra_fixture: &str) { + check_impl(ra_fixture, false, false, false) +} + +fn check_impl(ra_fixture: &str, allow_none: bool, only_types: bool, display_source: bool) { + let _tracing = setup_tracing(); + let (db, files) = TestDB::with_many_files(ra_fixture); + + let mut had_annotations = false; + let mut mismatches = HashMap::new(); + let mut types = HashMap::new(); + let mut adjustments = HashMap::<_, Vec<_>>::new(); + for (file_id, annotations) in db.extract_annotations() { + for (range, expected) in annotations { + let file_range = FileRange { file_id, range }; + if only_types { + types.insert(file_range, expected); + } else if expected.starts_with("type: ") { + types.insert(file_range, expected.trim_start_matches("type: ").to_string()); + } else if expected.starts_with("expected") { + mismatches.insert(file_range, expected); + } else if expected.starts_with("adjustments: ") { + adjustments.insert( + file_range, + expected + .trim_start_matches("adjustments: ") + .split(',') + .map(|it| it.trim().to_string()) + .filter(|it| !it.is_empty()) + .collect(), + ); + } else { + panic!("unexpected annotation: {}", expected); + } + had_annotations = true; + } + } + assert!(had_annotations || allow_none, "no `//^` annotations found"); + + let mut defs: Vec<DefWithBodyId> = Vec::new(); + for file_id in files { + let module = db.module_for_file_opt(file_id); + let module = match module { + Some(m) => m, + None => continue, + }; + let def_map = module.def_map(&db); + visit_module(&db, &def_map, module.local_id, &mut |it| defs.push(it)); + } + defs.sort_by_key(|def| match def { + DefWithBodyId::FunctionId(it) => { + let loc = it.lookup(&db); + loc.source(&db).value.syntax().text_range().start() + } + DefWithBodyId::ConstId(it) => { + let loc = it.lookup(&db); + loc.source(&db).value.syntax().text_range().start() + } + DefWithBodyId::StaticId(it) => { + let loc = it.lookup(&db); + loc.source(&db).value.syntax().text_range().start() + } + }); + let mut unexpected_type_mismatches = String::new(); + for def in defs { + let (_body, body_source_map) = db.body_with_source_map(def); + let inference_result = db.infer(def); + + for (pat, ty) in inference_result.type_of_pat.iter() { + let node = match pat_node(&body_source_map, pat, &db) { + Some(value) => value, + None => continue, + }; + let range = node.as_ref().original_file_range(&db); + if let Some(expected) = types.remove(&range) { + let actual = if display_source { + ty.display_source_code(&db, def.module(&db)).unwrap() + } else { + ty.display_test(&db).to_string() + }; + assert_eq!(actual, expected); + } + } + + for (expr, ty) in inference_result.type_of_expr.iter() { + let node = match expr_node(&body_source_map, expr, &db) { + Some(value) => value, + None => continue, + }; + let range = node.as_ref().original_file_range(&db); + if let Some(expected) = types.remove(&range) { + let actual = if display_source { + ty.display_source_code(&db, def.module(&db)).unwrap() + } else { + ty.display_test(&db).to_string() + }; + assert_eq!(actual, expected); + } + if let Some(expected) = adjustments.remove(&range) { + if let Some(adjustments) = inference_result.expr_adjustments.get(&expr) { + assert_eq!( + expected, + adjustments + .iter() + .map(|Adjustment { kind, .. }| format!("{:?}", kind)) + .collect::<Vec<_>>() + ); + } else { + panic!("expected {:?} adjustments, found none", expected); + } + } + } + + for (pat, mismatch) in inference_result.pat_type_mismatches() { + let node = match pat_node(&body_source_map, pat, &db) { + Some(value) => value, + None => continue, + }; + let range = node.as_ref().original_file_range(&db); + let actual = format!( + "expected {}, got {}", + mismatch.expected.display_test(&db), + mismatch.actual.display_test(&db) + ); + match mismatches.remove(&range) { + Some(annotation) => assert_eq!(actual, annotation), + None => format_to!(unexpected_type_mismatches, "{:?}: {}\n", range.range, actual), + } + } + for (expr, mismatch) in inference_result.expr_type_mismatches() { + let node = match body_source_map.expr_syntax(expr) { + Ok(sp) => { + let root = db.parse_or_expand(sp.file_id).unwrap(); + sp.map(|ptr| ptr.to_node(&root).syntax().clone()) + } + Err(SyntheticSyntax) => continue, + }; + let range = node.as_ref().original_file_range(&db); + let actual = format!( + "expected {}, got {}", + mismatch.expected.display_test(&db), + mismatch.actual.display_test(&db) + ); + match mismatches.remove(&range) { + Some(annotation) => assert_eq!(actual, annotation), + None => format_to!(unexpected_type_mismatches, "{:?}: {}\n", range.range, actual), + } + } + } + + let mut buf = String::new(); + if !unexpected_type_mismatches.is_empty() { + format_to!(buf, "Unexpected type mismatches:\n{}", unexpected_type_mismatches); + } + if !mismatches.is_empty() { + format_to!(buf, "Unchecked mismatch annotations:\n"); + for m in mismatches { + format_to!(buf, "{:?}: {}\n", m.0.range, m.1); + } + } + if !types.is_empty() { + format_to!(buf, "Unchecked type annotations:\n"); + for t in types { + format_to!(buf, "{:?}: type {}\n", t.0.range, t.1); + } + } + if !adjustments.is_empty() { + format_to!(buf, "Unchecked adjustments annotations:\n"); + for t in adjustments { + format_to!(buf, "{:?}: type {:?}\n", t.0.range, t.1); + } + } + assert!(buf.is_empty(), "{}", buf); +} + +fn expr_node( + body_source_map: &BodySourceMap, + expr: ExprId, + db: &TestDB, +) -> Option<InFile<SyntaxNode>> { + Some(match body_source_map.expr_syntax(expr) { + Ok(sp) => { + let root = db.parse_or_expand(sp.file_id).unwrap(); + sp.map(|ptr| ptr.to_node(&root).syntax().clone()) + } + Err(SyntheticSyntax) => return None, + }) +} + +fn pat_node( + body_source_map: &BodySourceMap, + pat: PatId, + db: &TestDB, +) -> Option<InFile<SyntaxNode>> { + Some(match body_source_map.pat_syntax(pat) { + Ok(sp) => { + let root = db.parse_or_expand(sp.file_id).unwrap(); + sp.map(|ptr| { + ptr.either( + |it| it.to_node(&root).syntax().clone(), + |it| it.to_node(&root).syntax().clone(), + ) + }) + } + Err(SyntheticSyntax) => return None, + }) +} + +fn infer(ra_fixture: &str) -> String { + infer_with_mismatches(ra_fixture, false) +} + +fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String { + let _tracing = setup_tracing(); + let (db, file_id) = TestDB::with_single_file(content); + + let mut buf = String::new(); + + let mut infer_def = |inference_result: Arc<InferenceResult>, + body_source_map: Arc<BodySourceMap>| { + let mut types: Vec<(InFile<SyntaxNode>, &Ty)> = Vec::new(); + let mut mismatches: Vec<(InFile<SyntaxNode>, &TypeMismatch)> = Vec::new(); + + for (pat, ty) in inference_result.type_of_pat.iter() { + let syntax_ptr = match body_source_map.pat_syntax(pat) { + Ok(sp) => { + let root = db.parse_or_expand(sp.file_id).unwrap(); + sp.map(|ptr| { + ptr.either( + |it| it.to_node(&root).syntax().clone(), + |it| it.to_node(&root).syntax().clone(), + ) + }) + } + Err(SyntheticSyntax) => continue, + }; + types.push((syntax_ptr.clone(), ty)); + if let Some(mismatch) = inference_result.type_mismatch_for_pat(pat) { + mismatches.push((syntax_ptr, mismatch)); + } + } + + for (expr, ty) in inference_result.type_of_expr.iter() { + let node = match body_source_map.expr_syntax(expr) { + Ok(sp) => { + let root = db.parse_or_expand(sp.file_id).unwrap(); + sp.map(|ptr| ptr.to_node(&root).syntax().clone()) + } + Err(SyntheticSyntax) => continue, + }; + types.push((node.clone(), ty)); + if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr) { + mismatches.push((node, mismatch)); + } + } + + // sort ranges for consistency + types.sort_by_key(|(node, _)| { + let range = node.value.text_range(); + (range.start(), range.end()) + }); + for (node, ty) in &types { + let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.value.clone()) { + (self_param.name().unwrap().syntax().text_range(), "self".to_string()) + } else { + (node.value.text_range(), node.value.text().to_string().replace('\n', " ")) + }; + let macro_prefix = if node.file_id != file_id.into() { "!" } else { "" }; + format_to!( + buf, + "{}{:?} '{}': {}\n", + macro_prefix, + range, + ellipsize(text, 15), + ty.display_test(&db) + ); + } + if include_mismatches { + mismatches.sort_by_key(|(node, _)| { + let range = node.value.text_range(); + (range.start(), range.end()) + }); + for (src_ptr, mismatch) in &mismatches { + let range = src_ptr.value.text_range(); + let macro_prefix = if src_ptr.file_id != file_id.into() { "!" } else { "" }; + format_to!( + buf, + "{}{:?}: expected {}, got {}\n", + macro_prefix, + range, + mismatch.expected.display_test(&db), + mismatch.actual.display_test(&db), + ); + } + } + }; + + let module = db.module_for_file(file_id); + let def_map = module.def_map(&db); + + let mut defs: Vec<DefWithBodyId> = Vec::new(); + visit_module(&db, &def_map, module.local_id, &mut |it| defs.push(it)); + defs.sort_by_key(|def| match def { + DefWithBodyId::FunctionId(it) => { + let loc = it.lookup(&db); + loc.source(&db).value.syntax().text_range().start() + } + DefWithBodyId::ConstId(it) => { + let loc = it.lookup(&db); + loc.source(&db).value.syntax().text_range().start() + } + DefWithBodyId::StaticId(it) => { + let loc = it.lookup(&db); + loc.source(&db).value.syntax().text_range().start() + } + }); + for def in defs { + let (_body, source_map) = db.body_with_source_map(def); + let infer = db.infer(def); + infer_def(infer, source_map); + } + + buf.truncate(buf.trim_end().len()); + buf +} + +fn visit_module( + db: &TestDB, + crate_def_map: &DefMap, + module_id: LocalModuleId, + cb: &mut dyn FnMut(DefWithBodyId), +) { + visit_scope(db, crate_def_map, &crate_def_map[module_id].scope, cb); + for impl_id in crate_def_map[module_id].scope.impls() { + let impl_data = db.impl_data(impl_id); + for &item in impl_data.items.iter() { + match item { + AssocItemId::FunctionId(it) => { + let def = it.into(); + cb(def); + let body = db.body(def); + visit_body(db, &body, cb); + } + AssocItemId::ConstId(it) => { + let def = it.into(); + cb(def); + let body = db.body(def); + visit_body(db, &body, cb); + } + AssocItemId::TypeAliasId(_) => (), + } + } + } + + fn visit_scope( + db: &TestDB, + crate_def_map: &DefMap, + scope: &ItemScope, + cb: &mut dyn FnMut(DefWithBodyId), + ) { + for decl in scope.declarations() { + match decl { + ModuleDefId::FunctionId(it) => { + let def = it.into(); + cb(def); + let body = db.body(def); + visit_body(db, &body, cb); + } + ModuleDefId::ConstId(it) => { + let def = it.into(); + cb(def); + let body = db.body(def); + visit_body(db, &body, cb); + } + ModuleDefId::StaticId(it) => { + let def = it.into(); + cb(def); + let body = db.body(def); + visit_body(db, &body, cb); + } + ModuleDefId::TraitId(it) => { + let trait_data = db.trait_data(it); + for &(_, item) in trait_data.items.iter() { + match item { + AssocItemId::FunctionId(it) => cb(it.into()), + AssocItemId::ConstId(it) => cb(it.into()), + AssocItemId::TypeAliasId(_) => (), + } + } + } + ModuleDefId::ModuleId(it) => visit_module(db, crate_def_map, it.local_id, cb), + _ => (), + } + } + } + + fn visit_body(db: &TestDB, body: &Body, cb: &mut dyn FnMut(DefWithBodyId)) { + for (_, def_map) in body.blocks(db) { + for (mod_id, _) in def_map.modules() { + visit_module(db, &def_map, mod_id, cb); + } + } + } +} + +fn ellipsize(mut text: String, max_len: usize) -> String { + if text.len() <= max_len { + return text; + } + let ellipsis = "..."; + let e_len = ellipsis.len(); + let mut prefix_len = (max_len - e_len) / 2; + while !text.is_char_boundary(prefix_len) { + prefix_len += 1; + } + let mut suffix_len = max_len - e_len - prefix_len; + while !text.is_char_boundary(text.len() - suffix_len) { + suffix_len += 1; + } + text.replace_range(prefix_len..text.len() - suffix_len, ellipsis); + text +} + +fn check_infer(ra_fixture: &str, expect: Expect) { + let mut actual = infer(ra_fixture); + actual.push('\n'); + expect.assert_eq(&actual); +} + +fn check_infer_with_mismatches(ra_fixture: &str, expect: Expect) { + let mut actual = infer_with_mismatches(ra_fixture, true); + actual.push('\n'); + expect.assert_eq(&actual); +} + +#[test] +fn salsa_bug() { + let (mut db, pos) = TestDB::with_position( + " + //- /lib.rs + trait Index { + type Output; + } + + type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key; + + pub trait UnificationStoreBase: Index<Output = Key<Self>> { + type Key; + + fn len(&self) -> usize; + } + + pub trait UnificationStoreMut: UnificationStoreBase { + fn push(&mut self, value: Self::Key); + } + + fn main() { + let x = 1; + x.push(1);$0 + } + ", + ); + + let module = db.module_for_file(pos.file_id); + let crate_def_map = module.def_map(&db); + visit_module(&db, &crate_def_map, module.local_id, &mut |def| { + db.infer(def); + }); + + let new_text = " + //- /lib.rs + trait Index { + type Output; + } + + type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key; + + pub trait UnificationStoreBase: Index<Output = Key<Self>> { + type Key; + + fn len(&self) -> usize; + } + + pub trait UnificationStoreMut: UnificationStoreBase { + fn push(&mut self, value: Self::Key); + } + + fn main() { + + let x = 1; + x.push(1); + } + " + .to_string(); + + db.set_file_text(pos.file_id, Arc::new(new_text)); + + let module = db.module_for_file(pos.file_id); + let crate_def_map = module.def_map(&db); + visit_module(&db, &crate_def_map, module.local_id, &mut |def| { + db.infer(def); + }); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs new file mode 100644 index 000000000..bf59fadc2 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs @@ -0,0 +1,755 @@ +use super::{check, check_no_mismatches, check_types}; + +#[test] +fn block_expr_type_mismatch() { + check( + r" +fn test() { + let a: i32 = { 1i64 }; + // ^^^^ expected i32, got i64 +} + ", + ); +} + +#[test] +fn coerce_places() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +struct S<T> { a: T } + +fn f<T>(_: &[T]) -> T { loop {} } +fn g<T>(_: S<&[T]>) -> T { loop {} } + +fn gen<T>() -> *mut [T; 2] { loop {} } +fn test1<U>() -> *mut [U] { + gen() +} + +fn test2() { + let arr: &[u8; 1] = &[1]; + + let a: &[_] = arr; + let b = f(arr); + let c: &[_] = { arr }; + let d = g(S { a: arr }); + let e: [&[_]; 1] = [arr]; + let f: [&[_]; 2] = [arr; 2]; + let g: (&[_], &[_]) = (arr, arr); +} +"#, + ); +} + +#[test] +fn let_stmt_coerce() { + check( + r" +//- minicore: coerce_unsized +fn test() { + let x: &[isize] = &[1]; + // ^^^^ adjustments: Deref(None), Borrow(Ref(Not)), Pointer(Unsize) + let x: *const [isize] = &[1]; + // ^^^^ adjustments: Deref(None), Borrow(RawPtr(Not)), Pointer(Unsize) +} +", + ); +} + +#[test] +fn custom_coerce_unsized() { + check( + r#" +//- minicore: coerce_unsized +use core::{marker::Unsize, ops::CoerceUnsized}; + +struct A<T: ?Sized>(*const T); +struct B<T: ?Sized>(*const T); +struct C<T: ?Sized> { inner: *const T } + +impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {} +impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {} + +fn foo1<T>(x: A<[T]>) -> A<[T]> { x } +fn foo2<T>(x: B<[T]>) -> B<[T]> { x } +fn foo3<T>(x: C<[T]>) -> C<[T]> { x } + +fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) { + let d = foo1(a); + // ^ expected A<[{unknown}]>, got A<[u8; 2]> + let e = foo2(b); + // ^ type: B<[u8]> + let f = foo3(c); + // ^ type: C<[u8]> +} +"#, + ); +} + +#[test] +fn if_coerce() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +fn foo<T>(x: &[T]) -> &[T] { x } +fn test() { + let x = if true { + foo(&[1]) + // ^^^^ adjustments: Deref(None), Borrow(Ref(Not)), Pointer(Unsize) + } else { + &[1] + }; +} +"#, + ); +} + +#[test] +fn if_else_coerce() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +fn foo<T>(x: &[T]) -> &[T] { x } +fn test() { + let x = if true { + &[1] + } else { + foo(&[1]) + }; +} +"#, + ) +} + +#[test] +fn match_first_coerce() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +fn foo<T>(x: &[T]) -> &[T] { x } +fn test(i: i32) { + let x = match i { + 2 => foo(&[2]), + // ^^^^ adjustments: Deref(None), Borrow(Ref(Not)), Pointer(Unsize) + 1 => &[1], + _ => &[3], + }; +} +"#, + ); +} + +#[test] +fn match_second_coerce() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +fn foo<T>(x: &[T]) -> &[T] { loop {} } + // ^^^^^^^ adjustments: NeverToAny +fn test(i: i32) { + let x = match i { + 1 => &[1], + 2 => foo(&[2]), + _ => &[3], + }; +} +"#, + ); +} + +#[test] +fn coerce_merge_one_by_one1() { + cov_mark::check!(coerce_merge_fail_fallback); + + check( + r" +fn test() { + let t = &mut 1; + let x = match 1 { + 1 => t as *mut i32, + 2 => t as &i32, + //^^^^^^^^^ expected *mut i32, got &i32 + _ => t as *const i32, + // ^^^^^^^^^^^^^^^ adjustments: Pointer(MutToConstPointer) + + }; + x; + //^ type: *const i32 + +} + ", + ); +} + +#[test] +fn return_coerce_unknown() { + check_types( + r" +fn foo() -> u32 { + return unknown; + //^^^^^^^ u32 +} + ", + ); +} + +#[test] +fn coerce_autoderef() { + check_no_mismatches( + r" +struct Foo; +fn takes_ref_foo(x: &Foo) {} +fn test() { + takes_ref_foo(&Foo); + takes_ref_foo(&&Foo); + takes_ref_foo(&&&Foo); +}", + ); +} + +#[test] +fn coerce_autoderef_generic() { + check_no_mismatches( + r#" +struct Foo; +fn takes_ref<T>(x: &T) -> T { *x } +fn test() { + takes_ref(&Foo); + takes_ref(&&Foo); + takes_ref(&&&Foo); +} +"#, + ); +} + +#[test] +fn coerce_autoderef_block() { + check_no_mismatches( + r#" +//- minicore: deref +struct String {} +impl core::ops::Deref for String { type Target = str; } +fn takes_ref_str(x: &str) {} +fn returns_string() -> String { loop {} } +fn test() { + takes_ref_str(&{ returns_string() }); + // ^^^^^^^^^^^^^^^^^^^^^ adjustments: Deref(None), Deref(Some(OverloadedDeref(Not))), Borrow(Ref(Not)) +} +"#, + ); +} + +#[test] +fn coerce_autoderef_implication_1() { + check_no_mismatches( + r" +//- minicore: deref +struct Foo<T>; +impl core::ops::Deref for Foo<u32> { type Target = (); } + +fn takes_ref_foo<T>(x: &Foo<T>) {} +fn test() { + let foo = Foo; + //^^^ type: Foo<{unknown}> + takes_ref_foo(&foo); + + let foo = Foo; + //^^^ type: Foo<u32> + let _: &() = &foo; +}", + ); +} + +#[test] +fn coerce_autoderef_implication_2() { + check( + r" +//- minicore: deref +struct Foo<T>; +impl core::ops::Deref for Foo<u32> { type Target = (); } + +fn takes_ref_foo<T>(x: &Foo<T>) {} +fn test() { + let foo = Foo; + //^^^ type: Foo<{unknown}> + let _: &u32 = &Foo; + //^^^^ expected &u32, got &Foo<{unknown}> +}", + ); +} + +#[test] +fn closure_return_coerce() { + check_no_mismatches( + r" +fn foo() { + let x = || { + if true { + return &1u32; + } + &&1u32 + }; +}", + ); +} + +#[test] +fn assign_coerce() { + check_no_mismatches( + r" +//- minicore: deref +struct String; +impl core::ops::Deref for String { type Target = str; } +fn g(_text: &str) {} +fn f(text: &str) { + let mut text = text; + let tmp = String; + text = &tmp; + g(text); +} +", + ); +} + +#[test] +fn destructuring_assign_coerce() { + check_no_mismatches( + r" +//- minicore: deref +struct String; +impl core::ops::Deref for String { type Target = str; } +fn g(_text: &str) {} +fn f(text: &str) { + let mut text = text; + let tmp = String; + [text, _] = [&tmp, &tmp]; + g(text); +} +", + ); +} + +#[test] +fn coerce_fn_item_to_fn_ptr() { + check_no_mismatches( + r" +fn foo(x: u32) -> isize { 1 } +fn test() { + let f: fn(u32) -> isize = foo; + // ^^^ adjustments: Pointer(ReifyFnPointer) + let f: unsafe fn(u32) -> isize = foo; + // ^^^ adjustments: Pointer(ReifyFnPointer) +}", + ); +} + +#[test] +fn coerce_fn_items_in_match_arms() { + cov_mark::check!(coerce_fn_reification); + + check_types( + r" +fn foo1(x: u32) -> isize { 1 } +fn foo2(x: u32) -> isize { 2 } +fn foo3(x: u32) -> isize { 3 } +fn test() { + let x = match 1 { + 1 => foo1, + 2 => foo2, + _ => foo3, + }; + x; + //^ fn(u32) -> isize +}", + ); +} + +#[test] +fn coerce_closure_to_fn_ptr() { + check_no_mismatches( + r" +fn test() { + let f: fn(u32) -> isize = |x| { 1 }; +}", + ); +} + +#[test] +fn coerce_placeholder_ref() { + // placeholders should unify, even behind references + check_no_mismatches( + r" +struct S<T> { t: T } +impl<TT> S<TT> { + fn get(&self) -> &TT { + &self.t + } +}", + ); +} + +#[test] +fn coerce_unsize_array() { + check_types( + r#" +//- minicore: coerce_unsized +fn test() { + let f: &[usize] = &[1, 2, 3]; + //^ usize +}"#, + ); +} + +#[test] +fn coerce_unsize_trait_object_simple() { + check_types( + r#" +//- minicore: coerce_unsized +trait Foo<T, U> {} +trait Bar<U, T, X>: Foo<T, U> {} +trait Baz<T, X>: Bar<usize, T, X> {} + +struct S<T, X>; +impl<T, X> Foo<T, usize> for S<T, X> {} +impl<T, X> Bar<usize, T, X> for S<T, X> {} +impl<T, X> Baz<T, X> for S<T, X> {} + +fn test() { + let obj: &dyn Baz<i8, i16> = &S; + //^ S<i8, i16> + let obj: &dyn Bar<_, i8, i16> = &S; + //^ S<i8, i16> + let obj: &dyn Foo<i8, _> = &S; + //^ S<i8, {unknown}> +}"#, + ); +} + +#[test] +fn coerce_unsize_super_trait_cycle() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +trait A {} +trait B: C + A {} +trait C: B {} +trait D: C + +struct S; +impl A for S {} +impl B for S {} +impl C for S {} +impl D for S {} + +fn test() { + let obj: &dyn D = &S; + let obj: &dyn A = &S; +} +"#, + ); +} + +#[test] +fn coerce_unsize_generic() { + // FIXME: fix the type mismatches here + check( + r#" +//- minicore: coerce_unsized +struct Foo<T> { t: T }; +struct Bar<T>(Foo<T>); + +fn test() { + let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] }; + //^^^^^^^^^ expected [usize], got [usize; 3] + let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] }); + //^^^^^^^^^ expected [usize], got [usize; 3] +} +"#, + ); +} + +#[test] +fn coerce_unsize_apit() { + check( + r#" +//- minicore: coerce_unsized +trait Foo {} + +fn test(f: impl Foo, g: &(impl Foo + ?Sized)) { + let _: &dyn Foo = &f; + let _: &dyn Foo = g; + //^ expected &dyn Foo, got &impl Foo + ?Sized +} + "#, + ); +} + +#[test] +fn two_closures_lub() { + check_types( + r#" +fn foo(c: i32) { + let add = |a: i32, b: i32| a + b; + let sub = |a, b| a - b; + //^^^^^^^^^^^^ |i32, i32| -> i32 + if c > 42 { add } else { sub }; + //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ fn(i32, i32) -> i32 +} + "#, + ) +} + +#[test] +fn match_diverging_branch_1() { + check_types( + r#" +enum Result<T> { Ok(T), Err } +fn parse<T>() -> T { loop {} } + +fn test() -> i32 { + let a = match parse() { + Ok(val) => val, + Err => return 0, + }; + a + //^ i32 +} + "#, + ) +} + +#[test] +fn match_diverging_branch_2() { + // same as 1 except for order of branches + check_types( + r#" +enum Result<T> { Ok(T), Err } +fn parse<T>() -> T { loop {} } + +fn test() -> i32 { + let a = match parse() { + Err => return 0, + Ok(val) => val, + }; + a + //^ i32 +} + "#, + ) +} + +#[test] +fn panic_macro() { + check_no_mismatches( + r#" +mod panic { + #[macro_export] + pub macro panic_2015 { + () => ( + $crate::panicking::panic() + ), + } +} + +mod panicking { + pub fn panic() -> ! { loop {} } +} + +#[rustc_builtin_macro = "core_panic"] +macro_rules! panic { + // Expands to either `$crate::panic::panic_2015` or `$crate::panic::panic_2021` + // depending on the edition of the caller. + ($($arg:tt)*) => { + /* compiler built-in */ + }; +} + +fn main() { + panic!() +} + "#, + ); +} + +#[test] +fn coerce_unsize_expected_type_1() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +fn main() { + let foo: &[u32] = &[1, 2]; + let foo: &[u32] = match true { + true => &[1, 2], + false => &[1, 2, 3], + }; + let foo: &[u32] = if true { + &[1, 2] + } else { + &[1, 2, 3] + }; +} + "#, + ); +} + +#[test] +fn coerce_unsize_expected_type_2() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +struct InFile<T>; +impl<T> InFile<T> { + fn with_value<U>(self, value: U) -> InFile<U> { InFile } +} +struct RecordField; +trait AstNode {} +impl AstNode for RecordField {} + +fn takes_dyn(it: InFile<&dyn AstNode>) {} + +fn test() { + let x: InFile<()> = InFile; + let n = &RecordField; + takes_dyn(x.with_value(n)); +} + "#, + ); +} + +#[test] +fn coerce_unsize_expected_type_3() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +enum Option<T> { Some(T), None } +struct RecordField; +trait AstNode {} +impl AstNode for RecordField {} + +fn takes_dyn(it: Option<&dyn AstNode>) {} + +fn test() { + let x: InFile<()> = InFile; + let n = &RecordField; + takes_dyn(Option::Some(n)); +} + "#, + ); +} + +#[test] +fn coerce_unsize_expected_type_4() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +use core::{marker::Unsize, ops::CoerceUnsized}; + +struct B<T: ?Sized>(*const T); +impl<T: ?Sized> B<T> { + fn new(t: T) -> Self { B(&t) } +} + +impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {} + +fn test() { + let _: B<[isize]> = B::new({ [1, 2, 3] }); +} + "#, + ); +} + +#[test] +fn coerce_array_elems_lub() { + check_no_mismatches( + r#" +fn f() {} +fn g() {} + +fn test() { + [f, g]; +} + "#, + ); +} + +#[test] +fn coerce_type_var() { + check_types( + r#" +//- minicore: from, coerce_unsized +fn test() { + let x = (); + let _: &() = &x.into(); +} //^^^^^^^^ () +"#, + ) +} + +#[test] +fn coerce_overloaded_binary_op_rhs() { + check_types( + r#" +//- minicore: deref, add + +struct String {} +impl core::ops::Deref for String { type Target = str; } + +impl core::ops::Add<&str> for String { + type Output = String; +} + +fn test() { + let s1 = String {}; + let s2 = String {}; + s1 + &s2; + //^^^^^^^^ String +} + + "#, + ); +} + +#[test] +fn assign_coerce_struct_fields() { + check_no_mismatches( + r#" +//- minicore: coerce_unsized +struct S; +trait Tr {} +impl Tr for S {} +struct V<T> { t: T } + +fn main() { + let a: V<&dyn Tr>; + a = V { t: &S }; + + let mut a: V<&dyn Tr> = V { t: &S }; + a = V { t: &S }; +} + "#, + ); +} + +#[test] +fn destructuring_assign_coerce_struct_fields() { + check( + r#" +//- minicore: coerce_unsized +struct S; +trait Tr {} +impl Tr for S {} +struct V<T> { t: T } + +fn main() { + let a: V<&dyn Tr>; + (a,) = V { t: &S }; + //^^^^expected V<&S>, got (V<&dyn Tr>,) + + let mut a: V<&dyn Tr> = V { t: &S }; + (a,) = V { t: &S }; + //^^^^expected V<&S>, got (V<&dyn Tr>,) +} + "#, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/diagnostics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/diagnostics.rs new file mode 100644 index 000000000..f00fa9729 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/diagnostics.rs @@ -0,0 +1,75 @@ +use super::check; + +#[test] +fn function_return_type_mismatch_1() { + check( + r#" +fn test() -> &'static str { + 5 + //^ expected &str, got i32 +} +"#, + ); +} + +#[test] +fn function_return_type_mismatch_2() { + check( + r#" +fn test(x: bool) -> &'static str { + if x { + return 1; + //^ expected &str, got i32 + } + "ok" +} +"#, + ); +} + +#[test] +fn function_return_type_mismatch_3() { + check( + r#" +fn test(x: bool) -> &'static str { + if x { + return "ok"; + } + 1 + //^ expected &str, got i32 +} +"#, + ); +} + +#[test] +fn function_return_type_mismatch_4() { + check( + r#" +fn test(x: bool) -> &'static str { + if x { + "ok" + } else { + 1 + //^ expected &str, got i32 + } +} +"#, + ); +} + +#[test] +fn function_return_type_mismatch_5() { + check( + r#" +fn test(x: bool) -> &'static str { + if x { + 1 + //^ expected &str, got i32 + } else { + "ok" + } +} +"#, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/display_source_code.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/display_source_code.rs new file mode 100644 index 000000000..240942e48 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/display_source_code.rs @@ -0,0 +1,176 @@ +use super::check_types_source_code; + +#[test] +fn qualify_path_to_submodule() { + check_types_source_code( + r#" +mod foo { + pub struct Foo; +} + +fn bar() { + let foo: foo::Foo = foo::Foo; + foo; +} //^^^ foo::Foo + +"#, + ); +} + +#[test] +fn omit_default_type_parameters() { + check_types_source_code( + r#" +struct Foo<T = u8> { t: T } +fn main() { + let foo = Foo { t: 5u8 }; + foo; +} //^^^ Foo +"#, + ); + + check_types_source_code( + r#" +struct Foo<K, T = u8> { k: K, t: T } +fn main() { + let foo = Foo { k: 400, t: 5u8 }; + foo; +} //^^^ Foo<i32> +"#, + ); +} + +#[test] +fn render_raw_ptr_impl_ty() { + check_types_source_code( + r#" +//- minicore: sized +trait Unpin {} +fn foo() -> *const (impl Unpin + Sized) { loop {} } +fn main() { + let foo = foo(); + foo; +} //^^^ *const impl Unpin +"#, + ); +} + +#[test] +fn render_dyn_for_ty() { + // FIXME + check_types_source_code( + r#" +trait Foo<'a> {} + +fn foo(foo: &dyn for<'a> Foo<'a>) {} + // ^^^ &dyn Foo +"#, + ); +} + +#[test] +fn sized_bounds_apit() { + check_types_source_code( + r#" +//- minicore: sized +trait Foo {} +trait Bar<T> {} +struct S<T>; +fn test( + a: impl Foo, + b: impl Foo + Sized, + c: &(impl Foo + ?Sized), + d: S<impl Foo>, + ref_any: &impl ?Sized, + empty: impl, +) { + a; + //^ impl Foo + b; + //^ impl Foo + c; + //^ &impl Foo + ?Sized + d; + //^ S<impl Foo> + ref_any; + //^^^^^^^ &impl ?Sized + empty; +} //^^^^^ impl Sized +"#, + ); +} + +#[test] +fn sized_bounds_rpit() { + check_types_source_code( + r#" +//- minicore: sized +trait Foo {} +fn foo1() -> impl Foo { loop {} } +fn foo2() -> impl Foo + Sized { loop {} } +fn foo3() -> impl Foo + ?Sized { loop {} } +fn test() { + let foo = foo1(); + foo; + //^^^ impl Foo + let foo = foo2(); + foo; + //^^^ impl Foo + let foo = foo3(); + foo; +} //^^^ impl Foo + ?Sized +"#, + ); +} + +#[test] +fn parenthesize_ptr_rpit_sized_bounds() { + check_types_source_code( + r#" +//- minicore: sized +trait Foo {} +fn foo1() -> *const impl Foo { loop {} } +fn foo2() -> *const (impl Foo + Sized) { loop {} } +fn foo3() -> *const (impl Sized + Foo) { loop {} } +fn foo4() -> *const (impl Foo + ?Sized) { loop {} } +fn foo5() -> *const (impl ?Sized + Foo) { loop {} } +fn test() { + let foo = foo1(); + foo; + //^^^ *const impl Foo + let foo = foo2(); + foo; + //^^^ *const impl Foo + let foo = foo3(); + foo; + //^^^ *const impl Foo + let foo = foo4(); + foo; + //^^^ *const (impl Foo + ?Sized) + let foo = foo5(); + foo; +} //^^^ *const (impl Foo + ?Sized) +"#, + ); +} + +#[test] +fn sized_bounds_impl_traits_in_fn_signature() { + check_types_source_code( + r#" +//- minicore: sized +trait Foo {} +fn test( + a: fn(impl Foo) -> impl Foo, + b: fn(impl Foo + Sized) -> impl Foo + Sized, + c: fn(&(impl Foo + ?Sized)) -> &(impl Foo + ?Sized), +) { + a; + //^ fn(impl Foo) -> impl Foo + b; + //^ fn(impl Foo) -> impl Foo + c; +} //^ fn(&impl Foo + ?Sized) -> &impl Foo + ?Sized +"#, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs new file mode 100644 index 000000000..3e08e83e8 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs @@ -0,0 +1,51 @@ +use std::sync::Arc; + +use base_db::{fixture::WithFixture, SourceDatabaseExt}; + +use crate::{db::HirDatabase, test_db::TestDB}; + +use super::visit_module; + +#[test] +fn typing_whitespace_inside_a_function_should_not_invalidate_types() { + let (mut db, pos) = TestDB::with_position( + " + //- /lib.rs + fn foo() -> i32 { + $01 + 1 + } + ", + ); + { + let events = db.log_executed(|| { + let module = db.module_for_file(pos.file_id); + let crate_def_map = module.def_map(&db); + visit_module(&db, &crate_def_map, module.local_id, &mut |def| { + db.infer(def); + }); + }); + assert!(format!("{:?}", events).contains("infer")) + } + + let new_text = " + fn foo() -> i32 { + 1 + + + 1 + } + " + .to_string(); + + db.set_file_text(pos.file_id, Arc::new(new_text)); + + { + let events = db.log_executed(|| { + let module = db.module_for_file(pos.file_id); + let crate_def_map = module.def_map(&db); + visit_module(&db, &crate_def_map, module.local_id, &mut |def| { + db.infer(def); + }); + }); + assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events) + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs new file mode 100644 index 000000000..a1ab6060e --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs @@ -0,0 +1,1338 @@ +use expect_test::expect; +use test_utils::{bench, bench_fixture, skip_slow_tests}; + +use crate::tests::check_infer_with_mismatches; + +use super::{check_infer, check_types}; + +#[test] +fn cfg_impl_def() { + check_types( + r#" +//- /main.rs crate:main deps:foo cfg:test +use foo::S as T; +struct S; + +#[cfg(test)] +impl S { + fn foo1(&self) -> i32 { 0 } +} + +#[cfg(not(test))] +impl S { + fn foo2(&self) -> i32 { 0 } +} + +fn test() { + let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4()); + t; +} //^ (i32, {unknown}, i32, {unknown}) + +//- /foo.rs crate:foo +pub struct S; + +#[cfg(not(test))] +impl S { + pub fn foo3(&self) -> i32 { 0 } +} + +#[cfg(test)] +impl S { + pub fn foo4(&self) -> i32 { 0 } +} +"#, + ); +} + +#[test] +fn infer_macros_expanded() { + check_infer( + r#" + struct Foo(Vec<i32>); + + macro_rules! foo { + ($($item:expr),*) => { + { + Foo(vec![$($item,)*]) + } + }; + } + + fn main() { + let x = foo!(1,2); + } + "#, + expect![[r#" + !0..17 '{Foo(v...,2,])}': Foo + !1..4 'Foo': Foo({unknown}) -> Foo + !1..16 'Foo(vec![1,2,])': Foo + !5..15 'vec![1,2,]': {unknown} + 155..181 '{ ...,2); }': () + 165..166 'x': Foo + "#]], + ); +} + +#[test] +fn infer_legacy_textual_scoped_macros_expanded() { + check_infer( + r#" + struct Foo(Vec<i32>); + + #[macro_use] + mod m { + macro_rules! foo { + ($($item:expr),*) => { + { + Foo(vec![$($item,)*]) + } + }; + } + } + + fn main() { + let x = foo!(1,2); + let y = crate::foo!(1,2); + } + "#, + expect![[r#" + !0..17 '{Foo(v...,2,])}': Foo + !1..4 'Foo': Foo({unknown}) -> Foo + !1..16 'Foo(vec![1,2,])': Foo + !5..15 'vec![1,2,]': {unknown} + 194..250 '{ ...,2); }': () + 204..205 'x': Foo + 227..228 'y': {unknown} + 231..247 'crate:...!(1,2)': {unknown} + "#]], + ); +} + +#[test] +fn infer_path_qualified_macros_expanded() { + check_infer( + r#" + #[macro_export] + macro_rules! foo { + () => { 42i32 } + } + + mod m { + pub use super::foo as bar; + } + + fn main() { + let x = crate::foo!(); + let y = m::bar!(); + } + "#, + expect![[r#" + !0..5 '42i32': i32 + !0..5 '42i32': i32 + 110..163 '{ ...!(); }': () + 120..121 'x': i32 + 147..148 'y': i32 + "#]], + ); +} + +#[test] +fn expr_macro_def_expanded_in_various_places() { + check_infer( + r#" + macro spam() { + 1isize + } + + fn spam() { + spam!(); + (spam!()); + spam!().spam(spam!()); + for _ in spam!() {} + || spam!(); + while spam!() {} + break spam!(); + return spam!(); + match spam!() { + _ if spam!() => spam!(), + } + spam!()(spam!()); + Spam { spam: spam!() }; + spam!()[spam!()]; + await spam!(); + spam!() as usize; + &spam!(); + -spam!(); + spam!()..spam!(); + spam!() + spam!(); + } + "#, + expect![[r#" + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + 39..442 '{ ...!(); }': () + 73..94 'spam!(...am!())': {unknown} + 100..119 'for _ ...!() {}': () + 104..105 '_': {unknown} + 117..119 '{}': () + 124..134 '|| spam!()': || -> isize + 140..156 'while ...!() {}': () + 154..156 '{}': () + 161..174 'break spam!()': ! + 180..194 'return spam!()': ! + 200..254 'match ... }': isize + 224..225 '_': isize + 259..275 'spam!(...am!())': {unknown} + 281..303 'Spam {...m!() }': {unknown} + 309..325 'spam!(...am!()]': {unknown} + 350..366 'spam!(... usize': usize + 372..380 '&spam!()': &isize + 386..394 '-spam!()': isize + 400..416 'spam!(...pam!()': {unknown} + 422..439 'spam!(...pam!()': isize + "#]], + ); +} + +#[test] +fn expr_macro_rules_expanded_in_various_places() { + check_infer( + r#" + macro_rules! spam { + () => (1isize); + } + + fn spam() { + spam!(); + (spam!()); + spam!().spam(spam!()); + for _ in spam!() {} + || spam!(); + while spam!() {} + break spam!(); + return spam!(); + match spam!() { + _ if spam!() => spam!(), + } + spam!()(spam!()); + Spam { spam: spam!() }; + spam!()[spam!()]; + await spam!(); + spam!() as usize; + &spam!(); + -spam!(); + spam!()..spam!(); + spam!() + spam!(); + } + "#, + expect![[r#" + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + !0..6 '1isize': isize + 53..456 '{ ...!(); }': () + 87..108 'spam!(...am!())': {unknown} + 114..133 'for _ ...!() {}': () + 118..119 '_': {unknown} + 131..133 '{}': () + 138..148 '|| spam!()': || -> isize + 154..170 'while ...!() {}': () + 168..170 '{}': () + 175..188 'break spam!()': ! + 194..208 'return spam!()': ! + 214..268 'match ... }': isize + 238..239 '_': isize + 273..289 'spam!(...am!())': {unknown} + 295..317 'Spam {...m!() }': {unknown} + 323..339 'spam!(...am!()]': {unknown} + 364..380 'spam!(... usize': usize + 386..394 '&spam!()': &isize + 400..408 '-spam!()': isize + 414..430 'spam!(...pam!()': {unknown} + 436..453 'spam!(...pam!()': isize + "#]], + ); +} + +#[test] +fn expr_macro_expanded_in_stmts() { + check_infer( + r#" + macro_rules! id { ($($es:tt)*) => { $($es)* } } + fn foo() { + id! { let a = (); } + } + "#, + expect![[r#" + !0..8 'leta=();': () + !3..4 'a': () + !5..7 '()': () + 57..84 '{ ...); } }': () + "#]], + ); +} + +#[test] +fn recurisve_macro_expanded_in_stmts() { + check_infer( + r#" + macro_rules! ng { + ([$($tts:tt)*]) => { + $($tts)*; + }; + ([$($tts:tt)*] $head:tt $($rest:tt)*) => { + ng! { + [$($tts)* $head] $($rest)* + } + }; + } + fn foo() { + ng!([] let a = 3); + let b = a; + } + "#, + expect![[r#" + !0..7 'leta=3;': () + !0..13 'ng!{[leta=3]}': () + !0..13 'ng!{[leta=]3}': () + !0..13 'ng!{[leta]=3}': () + !0..13 'ng!{[let]a=3}': () + !3..4 'a': i32 + !5..6 '3': i32 + 196..237 '{ ...= a; }': () + 229..230 'b': i32 + 233..234 'a': i32 + "#]], + ); +} + +#[test] +fn recursive_inner_item_macro_rules() { + check_infer( + r#" + macro_rules! mac { + () => { mac!($)}; + ($x:tt) => { macro_rules! blub { () => { 1 }; } }; + } + fn foo() { + mac!(); + let a = blub!(); + } + "#, + expect![[r#" + !0..1 '1': i32 + !0..7 'mac!($)': () + !0..26 'macro_...>{1};}': () + 107..143 '{ ...!(); }': () + 129..130 'a': i32 + "#]], + ); +} + +#[test] +fn infer_macro_defining_block_with_items() { + check_infer( + r#" + macro_rules! foo { + () => {{ + fn bar() -> usize { 0 } + bar() + }}; + } + fn main() { + let _a = foo!(); + } + "#, + expect![[r#" + !15..18 '{0}': usize + !16..17 '0': usize + !0..24 '{fnbar...bar()}': usize + !18..21 'bar': fn bar() -> usize + !18..23 'bar()': usize + 98..122 '{ ...!(); }': () + 108..110 '_a': usize + "#]], + ); +} + +#[test] +fn infer_type_value_macro_having_same_name() { + check_infer( + r#" + #[macro_export] + macro_rules! foo { + () => { + mod foo { + pub use super::foo; + } + }; + ($x:tt) => { + $x + }; + } + + foo!(); + + fn foo() { + let foo = foo::foo!(42i32); + } + "#, + expect![[r#" + !0..5 '42i32': i32 + 170..205 '{ ...32); }': () + 180..183 'foo': i32 + "#]], + ); +} + +#[test] +fn processes_impls_generated_by_macros() { + check_types( + r#" +macro_rules! m { + ($ident:ident) => (impl Trait for $ident {}) +} +trait Trait { fn foo(self) -> u128 { 0 } } +struct S; +m!(S); +fn test() { S.foo(); } + //^^^^^^^ u128 +"#, + ); +} + +#[test] +fn infer_assoc_items_generated_by_macros() { + check_types( + r#" +macro_rules! m { + () => (fn foo(&self) -> u128 {0}) +} +struct S; +impl S { + m!(); +} + +fn test() { S.foo(); } + //^^^^^^^ u128 +"#, + ); +} + +#[test] +fn infer_assoc_items_generated_by_macros_chain() { + check_types( + r#" +macro_rules! m_inner { + () => {fn foo(&self) -> u128 {0}} +} +macro_rules! m { + () => {m_inner!();} +} + +struct S; +impl S { + m!(); +} + +fn test() { S.foo(); } + //^^^^^^^ u128 +"#, + ); +} + +#[test] +fn infer_macro_with_dollar_crate_is_correct_in_expr() { + check_types( + r#" +//- /main.rs crate:main deps:foo +fn test() { + let x = (foo::foo!(1), foo::foo!(2)); + x; +} //^ (i32, usize) + +//- /lib.rs crate:foo +#[macro_export] +macro_rules! foo { + (1) => { $crate::bar!() }; + (2) => { 1 + $crate::baz() }; +} + +#[macro_export] +macro_rules! bar { + () => { 42 } +} + +pub fn baz() -> usize { 31usize } +"#, + ); +} + +#[test] +fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() { + check_types( + r#" +//- /main.rs crate:main deps:foo +use foo::Trait; + +fn test() { + let msg = foo::Message(foo::MessageRef); + let r = msg.deref(); + r; + //^ &MessageRef +} + +//- /lib.rs crate:foo +pub struct MessageRef; +pub struct Message(MessageRef); + +pub trait Trait { + type Target; + fn deref(&self) -> &Self::Target; +} + +#[macro_export] +macro_rules! expand { + () => { + impl Trait for Message { + type Target = $crate::MessageRef; + fn deref(&self) -> &Self::Target { + &self.0 + } + } + } +} + +expand!(); +"#, + ); +} + +#[test] +fn infer_macro_with_dollar_crate_in_def_site() { + check_types( + r#" +//- /main.rs crate:main deps:foo +use foo::expand; + +macro_rules! list { + ($($tt:tt)*) => { $($tt)* } +} + +fn test() { + let r = expand!(); + r; + //^ u128 +} + +//- /lib.rs crate:foo +#[macro_export] +macro_rules! expand { + () => { list!($crate::m!()) }; +} + +#[macro_export] +macro_rules! m { + () => { 0u128 }; +} +"#, + ); +} + +#[test] +fn infer_type_value_non_legacy_macro_use_as() { + check_infer( + r#" + mod m { + macro_rules! _foo { + ($x:ident) => { type $x = u64; } + } + pub(crate) use _foo as foo; + } + + m::foo!(foo); + use foo as bar; + fn f() -> bar { 0 } + fn main() { + let _a = f(); + } + "#, + expect![[r#" + 158..163 '{ 0 }': u64 + 160..161 '0': u64 + 174..196 '{ ...f(); }': () + 184..186 '_a': u64 + 190..191 'f': fn f() -> u64 + 190..193 'f()': u64 + "#]], + ); +} + +#[test] +fn infer_local_macro() { + check_infer( + r#" + fn main() { + macro_rules! foo { + () => { 1usize } + } + let _a = foo!(); + } + "#, + expect![[r#" + !0..6 '1usize': usize + 10..89 '{ ...!(); }': () + 74..76 '_a': usize + "#]], + ); +} + +#[test] +fn infer_local_inner_macros() { + check_types( + r#" +//- /main.rs crate:main deps:foo +fn test() { + let x = foo::foo!(1); + x; +} //^ i32 + +//- /lib.rs crate:foo +#[macro_export(local_inner_macros)] +macro_rules! foo { + (1) => { bar!() }; +} + +#[macro_export] +macro_rules! bar { + () => { 42 } +} + +"#, + ); +} + +#[test] +fn infer_builtin_macros_line() { + check_infer( + r#" + #[rustc_builtin_macro] + macro_rules! line {() => {}} + + fn main() { + let x = line!(); + } + "#, + expect![[r#" + !0..1 '0': i32 + 63..87 '{ ...!(); }': () + 73..74 'x': i32 + "#]], + ); +} + +#[test] +fn infer_builtin_macros_file() { + check_infer( + r#" + #[rustc_builtin_macro] + macro_rules! file {() => {}} + + fn main() { + let x = file!(); + } + "#, + expect![[r#" + !0..2 '""': &str + 63..87 '{ ...!(); }': () + 73..74 'x': &str + "#]], + ); +} + +#[test] +fn infer_builtin_macros_column() { + check_infer( + r#" + #[rustc_builtin_macro] + macro_rules! column {() => {}} + + fn main() { + let x = column!(); + } + "#, + expect![[r#" + !0..1 '0': i32 + 65..91 '{ ...!(); }': () + 75..76 'x': i32 + "#]], + ); +} + +#[test] +fn infer_builtin_macros_concat() { + check_infer( + r#" + #[rustc_builtin_macro] + macro_rules! concat {() => {}} + + fn main() { + let x = concat!("hello", concat!("world", "!")); + } + "#, + expect![[r#" + !0..13 '"helloworld!"': &str + 65..121 '{ ...")); }': () + 75..76 'x': &str + "#]], + ); +} + +#[test] +fn infer_builtin_macros_include() { + check_types( + r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! include {() => {}} + +include!("foo.rs"); + +fn main() { + bar(); +} //^^^^^ u32 + +//- /foo.rs +fn bar() -> u32 {0} +"#, + ); +} + +#[test] +fn infer_builtin_macros_include_expression() { + check_types( + r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! include {() => {}} +fn main() { + let i = include!("bla.rs"); + i; + //^ i32 +} +//- /bla.rs +0 + "#, + ) +} + +#[test] +fn infer_builtin_macros_include_child_mod() { + check_types( + r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! include {() => {}} + +include!("f/foo.rs"); + +fn main() { + bar::bar(); +} //^^^^^^^^^^ u32 + +//- /f/foo.rs +pub mod bar; + +//- /f/bar.rs +pub fn bar() -> u32 {0} +"#, + ); +} + +#[test] +fn infer_builtin_macros_include_str() { + check_types( + r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! include_str {() => {}} + +fn main() { + let a = include_str!("foo.rs"); + a; +} //^ &str + +//- /foo.rs +hello +"#, + ); +} + +#[test] +fn infer_builtin_macros_include_str_with_lazy_nested() { + check_types( + r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! concat {() => {}} +#[rustc_builtin_macro] +macro_rules! include_str {() => {}} + +macro_rules! m { + ($x:expr) => { + concat!("foo", $x) + }; +} + +fn main() { + let a = include_str!(m!(".rs")); + a; +} //^ &str + +//- /foo.rs +hello +"#, + ); +} + +#[test] +fn benchmark_include_macro() { + if skip_slow_tests() { + return; + } + let data = bench_fixture::big_struct(); + let fixture = r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! include {() => {}} + +include!("foo.rs"); + +fn main() { + RegisterBlock { }; + //^^^^^^^^^^^^^^^^^ RegisterBlock +} + "#; + let fixture = format!("{}\n//- /foo.rs\n{}", fixture, data); + + { + let _b = bench("include macro"); + check_types(&fixture); + } +} + +#[test] +fn infer_builtin_macros_include_concat() { + check_types( + r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! include {() => {}} + +#[rustc_builtin_macro] +macro_rules! concat {() => {}} + +include!(concat!("f", "oo.rs")); + +fn main() { + bar(); +} //^^^^^ u32 + +//- /foo.rs +fn bar() -> u32 {0} +"#, + ); +} + +#[test] +fn infer_builtin_macros_include_concat_with_bad_env_should_failed() { + check_types( + r#" +//- /main.rs +#[rustc_builtin_macro] +macro_rules! include {() => {}} + +#[rustc_builtin_macro] +macro_rules! concat {() => {}} + +#[rustc_builtin_macro] +macro_rules! env {() => {}} + +include!(concat!(env!("OUT_DIR"), "/foo.rs")); + +fn main() { + bar(); +} //^^^^^ {unknown} + +//- /foo.rs +fn bar() -> u32 {0} +"#, + ); +} + +#[test] +fn infer_builtin_macros_include_itself_should_failed() { + check_types( + r#" +#[rustc_builtin_macro] +macro_rules! include {() => {}} + +include!("main.rs"); + +fn main() { + 0; +} //^ i32 +"#, + ); +} + +#[test] +fn infer_builtin_macros_concat_with_lazy() { + check_infer( + r#" + macro_rules! hello {() => {"hello"}} + + #[rustc_builtin_macro] + macro_rules! concat {() => {}} + + fn main() { + let x = concat!(hello!(), concat!("world", "!")); + } + "#, + expect![[r#" + !0..13 '"helloworld!"': &str + 103..160 '{ ...")); }': () + 113..114 'x': &str + "#]], + ); +} + +#[test] +fn infer_builtin_macros_env() { + check_infer( + r#" + //- /main.rs env:foo=bar + #[rustc_builtin_macro] + macro_rules! env {() => {}} + + fn main() { + let x = env!("foo"); + } + "#, + expect![[r#" + !0..22 '"__RA_...TED__"': &str + 62..90 '{ ...o"); }': () + 72..73 'x': &str + "#]], + ); +} + +#[test] +fn infer_derive_clone_simple() { + check_types( + r#" +//- minicore: derive, clone +#[derive(Clone)] +struct S; +fn test() { + S.clone(); +} //^^^^^^^^^ S +"#, + ); +} + +#[test] +fn infer_derive_clone_with_params() { + check_types( + r#" +//- minicore: clone, derive +#[derive(Clone)] +struct S; +#[derive(Clone)] +struct Wrapper<T>(T); +struct NonClone; +fn test() { + let x = (Wrapper(S).clone(), Wrapper(NonClone).clone()); + x; + //^ (Wrapper<S>, {unknown}) +} +"#, + ); +} + +#[test] +fn infer_custom_derive_simple() { + // FIXME: this test current now do nothing + check_types( + r#" +//- minicore: derive +use foo::Foo; + +#[derive(Foo)] +struct S{} + +fn test() { + S{}; +} //^^^ S +"#, + ); +} + +#[test] +fn macro_in_arm() { + check_infer( + r#" + macro_rules! unit { + () => { () }; + } + + fn main() { + let x = match () { + unit!() => 92u32, + }; + } + "#, + expect![[r#" + !0..2 '()': () + 51..110 '{ ... }; }': () + 61..62 'x': u32 + 65..107 'match ... }': u32 + 71..73 '()': () + 95..100 '92u32': u32 + "#]], + ); +} + +#[test] +fn macro_in_type_alias_position() { + check_infer( + r#" + macro_rules! U32 { + () => { u32 }; + } + + trait Foo { + type Ty; + } + + impl<T> Foo for T { + type Ty = U32!(); + } + + type TayTo = U32!(); + + fn testy() { + let a: <() as Foo>::Ty; + let b: TayTo; + } + "#, + expect![[r#" + 147..196 '{ ...yTo; }': () + 157..158 'a': u32 + 185..186 'b': u32 + "#]], + ); +} + +#[test] +fn nested_macro_in_type_alias_position() { + check_infer( + r#" + macro_rules! U32Inner2 { + () => { u32 }; + } + + macro_rules! U32Inner1 { + () => { U32Inner2!() }; + } + + macro_rules! U32 { + () => { U32Inner1!() }; + } + + trait Foo { + type Ty; + } + + impl<T> Foo for T { + type Ty = U32!(); + } + + type TayTo = U32!(); + + fn testy() { + let a: <() as Foo>::Ty; + let b: TayTo; + } + "#, + expect![[r#" + 259..308 '{ ...yTo; }': () + 269..270 'a': u32 + 297..298 'b': u32 + "#]], + ); +} + +#[test] +fn macros_in_type_alias_position_generics() { + check_infer( + r#" + struct Foo<A, B>(A, B); + + macro_rules! U32 { + () => { u32 }; + } + + macro_rules! Bar { + () => { Foo<U32!(), U32!()> }; + } + + trait Moo { + type Ty; + } + + impl<T> Moo for T { + type Ty = Bar!(); + } + + type TayTo = Bar!(); + + fn main() { + let a: <() as Moo>::Ty; + let b: TayTo; + } + "#, + expect![[r#" + 228..277 '{ ...yTo; }': () + 238..239 'a': Foo<u32, u32> + 266..267 'b': Foo<u32, u32> + "#]], + ); +} + +#[test] +fn macros_in_type_position() { + check_infer( + r#" + struct Foo<A, B>(A, B); + + macro_rules! U32 { + () => { u32 }; + } + + macro_rules! Bar { + () => { Foo<U32!(), U32!()> }; + } + + fn main() { + let a: Bar!(); + } + "#, + expect![[r#" + 133..155 '{ ...!(); }': () + 143..144 'a': Foo<u32, u32> + "#]], + ); +} + +#[test] +fn macros_in_type_generics() { + check_infer( + r#" + struct Foo<A, B>(A, B); + + macro_rules! U32 { + () => { u32 }; + } + + macro_rules! Bar { + () => { Foo<U32!(), U32!()> }; + } + + trait Moo { + type Ty; + } + + impl<T> Moo for T { + type Ty = Foo<Bar!(), Bar!()>; + } + + type TayTo = Foo<Bar!(), U32!()>; + + fn main() { + let a: <() as Moo>::Ty; + let b: TayTo; + } + "#, + expect![[r#" + 254..303 '{ ...yTo; }': () + 264..265 'a': Foo<Foo<u32, u32>, Foo<u32, u32>> + 292..293 'b': Foo<Foo<u32, u32>, u32> + "#]], + ); +} + +#[test] +fn infinitely_recursive_macro_type() { + check_infer( + r#" + struct Bar<T, X>(T, X); + + macro_rules! Foo { + () => { Foo!() } + } + + macro_rules! U32 { + () => { u32 } + } + + type A = Foo!(); + type B = Bar<Foo!(), U32!()>; + + fn main() { + let a: A; + let b: B; + } + "#, + expect![[r#" + 166..197 '{ ...: B; }': () + 176..177 'a': {unknown} + 190..191 'b': Bar<{unknown}, u32> + "#]], + ); +} + +#[test] +fn cfg_tails() { + check_infer_with_mismatches( + r#" +//- /lib.rs crate:foo cfg:feature=foo +struct S {} + +impl S { + fn new2(bar: u32) -> Self { + #[cfg(feature = "foo")] + { Self { } } + #[cfg(not(feature = "foo"))] + { Self { } } + } +} +"#, + expect![[r#" + 34..37 'bar': u32 + 52..170 '{ ... }': S + 62..106 '#[cfg(... { } }': S + 96..104 'Self { }': S + "#]], + ); +} + +#[test] +fn infer_in_unexpandable_attr_proc_macro_1() { + check_types( + r#" +//- /main.rs crate:main deps:mac +#[mac::attr_macro] +fn foo() { + let xxx = 1; + //^^^ i32 +} + +//- /mac.rs crate:mac +#![crate_type="proc-macro"] +#[proc_macro_attribute] +pub fn attr_macro() {} +"#, + ); +} + +#[test] +fn infer_in_unexpandable_attr_proc_macro_in_impl() { + check_types( + r#" +//- /main.rs crate:main deps:mac +struct Foo; +impl Foo { + #[mac::attr_macro] + fn foo() { + let xxx = 1; + //^^^ i32 + } +} + +//- /mac.rs crate:mac +#![crate_type="proc-macro"] +#[proc_macro_attribute] +pub fn attr_macro() {} +"#, + ); +} + +#[test] +fn infer_in_unexpandable_attr_proc_macro_in_trait() { + check_types( + r#" +//- /main.rs crate:main deps:mac +trait Foo { + #[mac::attr_macro] + fn foo() { + let xxx = 1; + //^^^ i32 + } +} + +//- /mac.rs crate:mac +#![crate_type="proc-macro"] +#[proc_macro_attribute] +pub fn attr_macro() {} +"#, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs new file mode 100644 index 000000000..68463dc06 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs @@ -0,0 +1,1792 @@ +use expect_test::expect; + +use crate::tests::check; + +use super::{check_infer, check_no_mismatches, check_types}; + +#[test] +fn infer_slice_method() { + check_types( + r#" +impl<T> [T] { + fn foo(&self) -> T { + loop {} + } +} + +fn test(x: &[u8]) { + <[_]>::foo(x); + //^^^^^^^^^^^^^ u8 +} + "#, + ); +} + +#[test] +fn cross_crate_primitive_method() { + check_types( + r#" +//- /main.rs crate:main deps:other_crate +fn test() { + let x = 1f32; + x.foo(); +} //^^^^^^^ f32 + +//- /lib.rs crate:other_crate +mod foo { + impl f32 { + pub fn foo(self) -> f32 { 0. } + } +} +"#, + ); +} + +#[test] +fn infer_array_inherent_impl() { + check_types( + r#" +impl<T, const N: usize> [T; N] { + fn foo(&self) -> T { + loop {} + } +} +fn test(x: &[u8; 0]) { + <[_; 0]>::foo(x); + //^^^^^^^^^^^^^^^^ u8 +} + "#, + ); +} + +#[test] +fn infer_associated_method_struct() { + check_infer( + r#" + struct A { x: u32 } + + impl A { + fn new() -> A { + A { x: 0 } + } + } + fn test() { + let a = A::new(); + a.x; + } + "#, + expect![[r#" + 48..74 '{ ... }': A + 58..68 'A { x: 0 }': A + 65..66 '0': u32 + 87..121 '{ ...a.x; }': () + 97..98 'a': A + 101..107 'A::new': fn new() -> A + 101..109 'A::new()': A + 115..116 'a': A + 115..118 'a.x': u32 + "#]], + ); +} + +#[test] +fn infer_associated_method_struct_in_local_scope() { + check_infer( + r#" + fn mismatch() { + struct A; + + impl A { + fn from(_: i32, _: i32) -> Self { + A + } + } + + let _a = A::from(1, 2); + } + "#, + expect![[r#" + 14..146 '{ ... 2); }': () + 125..127 '_a': A + 130..137 'A::from': fn from(i32, i32) -> A + 130..143 'A::from(1, 2)': A + 138..139 '1': i32 + 141..142 '2': i32 + 60..61 '_': i32 + 68..69 '_': i32 + 84..109 '{ ... }': A + 98..99 'A': A + "#]], + ); +} + +#[test] +fn infer_associated_method_enum() { + check_infer( + r#" + enum A { B, C } + + impl A { + pub fn b() -> A { + A::B + } + pub fn c() -> A { + A::C + } + } + fn test() { + let a = A::b(); + a; + let c = A::c(); + c; + } + "#, + expect![[r#" + 46..66 '{ ... }': A + 56..60 'A::B': A + 87..107 '{ ... }': A + 97..101 'A::C': A + 120..177 '{ ... c; }': () + 130..131 'a': A + 134..138 'A::b': fn b() -> A + 134..140 'A::b()': A + 146..147 'a': A + 157..158 'c': A + 161..165 'A::c': fn c() -> A + 161..167 'A::c()': A + 173..174 'c': A + "#]], + ); +} + +#[test] +fn infer_associated_method_with_modules() { + check_infer( + r#" + mod a { + struct A; + impl A { pub fn thing() -> A { A {} }} + } + + mod b { + struct B; + impl B { pub fn thing() -> u32 { 99 }} + + mod c { + struct C; + impl C { pub fn thing() -> C { C {} }} + } + } + use b::c; + + fn test() { + let x = a::A::thing(); + let y = b::B::thing(); + let z = c::C::thing(); + } + "#, + expect![[r#" + 55..63 '{ A {} }': A + 57..61 'A {}': A + 125..131 '{ 99 }': u32 + 127..129 '99': u32 + 201..209 '{ C {} }': C + 203..207 'C {}': C + 240..324 '{ ...g(); }': () + 250..251 'x': A + 254..265 'a::A::thing': fn thing() -> A + 254..267 'a::A::thing()': A + 277..278 'y': u32 + 281..292 'b::B::thing': fn thing() -> u32 + 281..294 'b::B::thing()': u32 + 304..305 'z': C + 308..319 'c::C::thing': fn thing() -> C + 308..321 'c::C::thing()': C + "#]], + ); +} + +#[test] +fn infer_associated_method_generics() { + check_infer( + r#" + struct Gen<T> { + val: T + } + + impl<T> Gen<T> { + pub fn make(val: T) -> Gen<T> { + Gen { val } + } + } + + fn test() { + let a = Gen::make(0u32); + } + "#, + expect![[r#" + 63..66 'val': T + 81..108 '{ ... }': Gen<T> + 91..102 'Gen { val }': Gen<T> + 97..100 'val': T + 122..154 '{ ...32); }': () + 132..133 'a': Gen<u32> + 136..145 'Gen::make': fn make<u32>(u32) -> Gen<u32> + 136..151 'Gen::make(0u32)': Gen<u32> + 146..150 '0u32': u32 + "#]], + ); +} + +#[test] +fn infer_associated_method_generics_without_args() { + check_infer( + r#" + struct Gen<T> { + val: T + } + + impl<T> Gen<T> { + pub fn make() -> Gen<T> { + loop { } + } + } + + fn test() { + let a = Gen::<u32>::make(); + } + "#, + expect![[r#" + 75..99 '{ ... }': Gen<T> + 85..93 'loop { }': ! + 90..93 '{ }': () + 113..148 '{ ...e(); }': () + 123..124 'a': Gen<u32> + 127..143 'Gen::<...::make': fn make<u32>() -> Gen<u32> + 127..145 'Gen::<...make()': Gen<u32> + "#]], + ); +} + +#[test] +fn infer_associated_method_generics_2_type_params_without_args() { + check_infer( + r#" + struct Gen<T, U> { + val: T, + val2: U, + } + + impl<T> Gen<u32, T> { + pub fn make() -> Gen<u32,T> { + loop { } + } + } + + fn test() { + let a = Gen::<u32, u64>::make(); + } + "#, + expect![[r#" + 101..125 '{ ... }': Gen<u32, T> + 111..119 'loop { }': ! + 116..119 '{ }': () + 139..179 '{ ...e(); }': () + 149..150 'a': Gen<u32, u64> + 153..174 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64> + 153..176 'Gen::<...make()': Gen<u32, u64> + "#]], + ); +} + +#[test] +fn cross_crate_associated_method_call() { + check_types( + r#" +//- /main.rs crate:main deps:other_crate +fn test() { + let x = other_crate::foo::S::thing(); + x; +} //^ i128 + +//- /lib.rs crate:other_crate +pub mod foo { + pub struct S; + impl S { + pub fn thing() -> i128 { 0 } + } +} +"#, + ); +} + +#[test] +fn infer_trait_method_simple() { + // the trait implementation is intentionally incomplete -- it shouldn't matter + check_types( + r#" +trait Trait1 { + fn method(&self) -> u32; +} +struct S1; +impl Trait1 for S1 {} +trait Trait2 { + fn method(&self) -> i128; +} +struct S2; +impl Trait2 for S2 {} +fn test() { + S1.method(); + //^^^^^^^^^^^ u32 + S2.method(); // -> i128 + //^^^^^^^^^^^ i128 +} + "#, + ); +} + +#[test] +fn infer_trait_method_scoped() { + // the trait implementation is intentionally incomplete -- it shouldn't matter + check_types( + r#" +struct S; +mod foo { + pub trait Trait1 { + fn method(&self) -> u32; + } + impl Trait1 for super::S {} +} +mod bar { + pub trait Trait2 { + fn method(&self) -> i128; + } + impl Trait2 for super::S {} +} + +mod foo_test { + use super::S; + use super::foo::Trait1; + fn test() { + S.method(); + //^^^^^^^^^^ u32 + } +} + +mod bar_test { + use super::S; + use super::bar::Trait2; + fn test() { + S.method(); + //^^^^^^^^^^ i128 + } +} + "#, + ); +} + +#[test] +fn infer_trait_method_generic_1() { + // the trait implementation is intentionally incomplete -- it shouldn't matter + check_types( + r#" +trait Trait<T> { + fn method(&self) -> T; +} +struct S; +impl Trait<u32> for S {} +fn test() { + S.method(); + //^^^^^^^^^^ u32 +} + "#, + ); +} + +#[test] +fn infer_trait_method_generic_more_params() { + // the trait implementation is intentionally incomplete -- it shouldn't matter + check_types( + r#" +trait Trait<T1, T2, T3> { + fn method1(&self) -> (T1, T2, T3); + fn method2(&self) -> (T3, T2, T1); +} +struct S1; +impl Trait<u8, u16, u32> for S1 {} +struct S2; +impl<T> Trait<i8, i16, T> for S2 {} +fn test() { + S1.method1(); + //^^^^^^^^^^^^ (u8, u16, u32) + S1.method2(); + //^^^^^^^^^^^^ (u32, u16, u8) + S2.method1(); + //^^^^^^^^^^^^ (i8, i16, {unknown}) + S2.method2(); + //^^^^^^^^^^^^ ({unknown}, i16, i8) +} + "#, + ); +} + +#[test] +fn infer_trait_method_generic_2() { + // the trait implementation is intentionally incomplete -- it shouldn't matter + check_types( + r#" +trait Trait<T> { + fn method(&self) -> T; +} +struct S<T>(T); +impl<U> Trait<U> for S<U> {} +fn test() { + S(1u32).method(); + //^^^^^^^^^^^^^^^^ u32 +} + "#, + ); +} + +#[test] +fn infer_trait_assoc_method() { + check_infer( + r#" + trait Default { + fn default() -> Self; + } + struct S; + impl Default for S {} + fn test() { + let s1: S = Default::default(); + let s2 = S::default(); + let s3 = <S as Default>::default(); + } + "#, + expect![[r#" + 86..192 '{ ...t(); }': () + 96..98 's1': S + 104..120 'Defaul...efault': fn default<S>() -> S + 104..122 'Defaul...ault()': S + 132..134 's2': S + 137..147 'S::default': fn default<S>() -> S + 137..149 'S::default()': S + 159..161 's3': S + 164..187 '<S as ...efault': fn default<S>() -> S + 164..189 '<S as ...ault()': S + "#]], + ); +} + +#[test] +fn infer_trait_assoc_method_generics_1() { + check_infer( + r#" + trait Trait<T> { + fn make() -> T; + } + struct S; + impl Trait<u32> for S {} + struct G<T>; + impl<T> Trait<T> for G<T> {} + fn test() { + let a = S::make(); + let b = G::<u64>::make(); + let c: f64 = G::make(); + } + "#, + expect![[r#" + 126..210 '{ ...e(); }': () + 136..137 'a': u32 + 140..147 'S::make': fn make<S, u32>() -> u32 + 140..149 'S::make()': u32 + 159..160 'b': u64 + 163..177 'G::<u64>::make': fn make<G<u64>, u64>() -> u64 + 163..179 'G::<u6...make()': u64 + 189..190 'c': f64 + 198..205 'G::make': fn make<G<f64>, f64>() -> f64 + 198..207 'G::make()': f64 + "#]], + ); +} + +#[test] +fn infer_trait_assoc_method_generics_2() { + check_infer( + r#" + trait Trait<T> { + fn make<U>() -> (T, U); + } + struct S; + impl Trait<u32> for S {} + struct G<T>; + impl<T> Trait<T> for G<T> {} + fn test() { + let a = S::make::<i64>(); + let b: (_, i64) = S::make(); + let c = G::<u32>::make::<i64>(); + let d: (u32, _) = G::make::<i64>(); + let e: (u32, i64) = G::make(); + } + "#, + expect![[r#" + 134..312 '{ ...e(); }': () + 144..145 'a': (u32, i64) + 148..162 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64) + 148..164 'S::mak...i64>()': (u32, i64) + 174..175 'b': (u32, i64) + 188..195 'S::make': fn make<S, u32, i64>() -> (u32, i64) + 188..197 'S::make()': (u32, i64) + 207..208 'c': (u32, i64) + 211..232 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64) + 211..234 'G::<u3...i64>()': (u32, i64) + 244..245 'd': (u32, i64) + 258..272 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64) + 258..274 'G::mak...i64>()': (u32, i64) + 284..285 'e': (u32, i64) + 300..307 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64) + 300..309 'G::make()': (u32, i64) + "#]], + ); +} + +#[test] +fn infer_trait_assoc_method_generics_3() { + check_infer( + r#" + trait Trait<T> { + fn make() -> (Self, T); + } + struct S<T>; + impl Trait<i64> for S<i32> {} + fn test() { + let a = S::make(); + } + "#, + expect![[r#" + 100..126 '{ ...e(); }': () + 110..111 'a': (S<i32>, i64) + 114..121 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64) + 114..123 'S::make()': (S<i32>, i64) + "#]], + ); +} + +#[test] +fn infer_trait_assoc_method_generics_4() { + check_infer( + r#" + trait Trait<T> { + fn make() -> (Self, T); + } + struct S<T>; + impl Trait<i64> for S<u64> {} + impl Trait<i32> for S<u32> {} + fn test() { + let a: (S<u64>, _) = S::make(); + let b: (_, i32) = S::make(); + } + "#, + expect![[r#" + 130..202 '{ ...e(); }': () + 140..141 'a': (S<u64>, i64) + 157..164 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64) + 157..166 'S::make()': (S<u64>, i64) + 176..177 'b': (S<u32>, i32) + 190..197 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32) + 190..199 'S::make()': (S<u32>, i32) + "#]], + ); +} + +#[test] +fn infer_trait_assoc_method_generics_5() { + check_infer( + r#" + trait Trait<T> { + fn make<U>() -> (Self, T, U); + } + struct S<T>; + impl Trait<i64> for S<u64> {} + fn test() { + let a = <S as Trait<i64>>::make::<u8>(); + let b: (S<u64>, _, _) = Trait::<i64>::make::<u8>(); + } + "#, + expect![[r#" + 106..210 '{ ...>(); }': () + 116..117 'a': (S<u64>, i64, u8) + 120..149 '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8) + 120..151 '<S as ...<u8>()': (S<u64>, i64, u8) + 161..162 'b': (S<u64>, i64, u8) + 181..205 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8) + 181..207 'Trait:...<u8>()': (S<u64>, i64, u8) + "#]], + ); +} + +#[test] +fn infer_call_trait_method_on_generic_param_1() { + check_infer( + r#" + trait Trait { + fn method(&self) -> u32; + } + fn test<T: Trait>(t: T) { + t.method(); + } + "#, + expect![[r#" + 29..33 'self': &Self + 63..64 't': T + 69..88 '{ ...d(); }': () + 75..76 't': T + 75..85 't.method()': u32 + "#]], + ); +} + +#[test] +fn infer_call_trait_method_on_generic_param_2() { + check_infer( + r#" + trait Trait<T> { + fn method(&self) -> T; + } + fn test<U, T: Trait<U>>(t: T) { + t.method(); + } + "#, + expect![[r#" + 32..36 'self': &Self + 70..71 't': T + 76..95 '{ ...d(); }': () + 82..83 't': T + 82..92 't.method()': U + "#]], + ); +} + +#[test] +fn infer_with_multiple_trait_impls() { + check_infer( + r#" + trait Into<T> { + fn into(self) -> T; + } + struct S; + impl Into<u32> for S {} + impl Into<u64> for S {} + fn test() { + let x: u32 = S.into(); + let y: u64 = S.into(); + let z = Into::<u64>::into(S); + } + "#, + expect![[r#" + 28..32 'self': Self + 110..201 '{ ...(S); }': () + 120..121 'x': u32 + 129..130 'S': S + 129..137 'S.into()': u32 + 147..148 'y': u64 + 156..157 'S': S + 156..164 'S.into()': u64 + 174..175 'z': u64 + 178..195 'Into::...::into': fn into<S, u64>(S) -> u64 + 178..198 'Into::...nto(S)': u64 + 196..197 'S': S + "#]], + ); +} + +#[test] +fn method_resolution_unify_impl_self_type() { + check_types( + r#" +struct S<T>; +impl S<u32> { fn foo(&self) -> u8 { 0 } } +impl S<i32> { fn foo(&self) -> i8 { 0 } } +fn test() { (S::<u32>.foo(), S::<i32>.foo()); } + //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (u8, i8) +"#, + ); +} + +#[test] +fn method_resolution_trait_before_autoref() { + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl S { fn foo(&self) -> i8 { 0 } } +impl Trait for S { fn foo(self) -> u128 { 0 } } +fn test() { S.foo(); } + //^^^^^^^ u128 +"#, + ); +} + +#[test] +fn method_resolution_by_value_before_autoref() { + check_types( + r#" +trait Clone { fn clone(&self) -> Self; } +struct S; +impl Clone for S {} +impl Clone for &S {} +fn test() { (S.clone(), (&S).clone(), (&&S).clone()); } + //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (S, S, &S) +"#, + ); +} + +#[test] +fn method_resolution_trait_before_autoderef() { + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl S { fn foo(self) -> i8 { 0 } } +impl Trait for &S { fn foo(self) -> u128 { 0 } } +fn test() { (&S).foo(); } + //^^^^^^^^^^ u128 +"#, + ); +} + +#[test] +fn method_resolution_impl_before_trait() { + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl S { fn foo(self) -> i8 { 0 } } +impl Trait for S { fn foo(self) -> u128 { 0 } } +fn test() { S.foo(); } + //^^^^^^^ i8 +"#, + ); +} + +#[test] +fn method_resolution_impl_ref_before_trait() { + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl S { fn foo(&self) -> i8 { 0 } } +impl Trait for &S { fn foo(self) -> u128 { 0 } } +fn test() { S.foo(); } + //^^^^^^^ i8 +"#, + ); +} + +#[test] +fn method_resolution_trait_autoderef() { + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl Trait for S { fn foo(self) -> u128 { 0 } } +fn test() { (&S).foo(); } + //^^^^^^^^^^ u128 +"#, + ); +} + +#[test] +fn method_resolution_unsize_array() { + check_types( + r#" +//- minicore: slice +fn test() { + let a = [1, 2, 3]; + a.len(); +} //^^^^^^^ usize +"#, + ); +} + +#[test] +fn method_resolution_trait_from_prelude() { + check_types( + r#" +//- /main.rs crate:main deps:core +struct S; +impl Clone for S {} + +fn test() { + S.clone(); + //^^^^^^^^^ S +} + +//- /lib.rs crate:core +pub mod prelude { + pub mod rust_2018 { + pub trait Clone { + fn clone(&self) -> Self; + } + } +} +"#, + ); +} + +#[test] +fn method_resolution_where_clause_for_unknown_trait() { + // The blanket impl currently applies because we ignore the unresolved where clause + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl<T> Trait for T where T: UnknownTrait {} +fn test() { (&S).foo(); } + //^^^^^^^^^^ u128 +"#, + ); +} + +#[test] +fn method_resolution_where_clause_not_met() { + // The blanket impl shouldn't apply because we can't prove S: Clone + // This is also to make sure that we don't resolve to the foo method just + // because that's the only method named foo we can find, which would make + // the below tests not work + check_types( + r#" +trait Clone {} +trait Trait { fn foo(self) -> u128; } +struct S; +impl<T> Trait for T where T: Clone {} +fn test() { (&S).foo(); } + //^^^^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn method_resolution_where_clause_inline_not_met() { + // The blanket impl shouldn't apply because we can't prove S: Clone + check_types( + r#" +trait Clone {} +trait Trait { fn foo(self) -> u128; } +struct S; +impl<T: Clone> Trait for T {} +fn test() { (&S).foo(); } + //^^^^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn method_resolution_where_clause_1() { + check_types( + r#" +trait Clone {} +trait Trait { fn foo(self) -> u128; } +struct S; +impl Clone for S {} +impl<T> Trait for T where T: Clone {} +fn test() { S.foo(); } + //^^^^^^^ u128 +"#, + ); +} + +#[test] +fn method_resolution_where_clause_2() { + check_types( + r#" +trait Into<T> { fn into(self) -> T; } +trait From<T> { fn from(other: T) -> Self; } +struct S1; +struct S2; +impl From<S2> for S1 {} +impl<T, U> Into<U> for T where U: From<T> {} +fn test() { S2.into(); } + //^^^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn method_resolution_where_clause_inline() { + check_types( + r#" +trait Into<T> { fn into(self) -> T; } +trait From<T> { fn from(other: T) -> Self; } +struct S1; +struct S2; +impl From<S2> for S1 {} +impl<T, U: From<T>> Into<U> for T {} +fn test() { S2.into(); } + //^^^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn method_resolution_overloaded_method() { + check_types( + r#" +struct Wrapper<T>(T); +struct Foo<T>(T); +struct Bar<T>(T); + +impl<T> Wrapper<Foo<T>> { + pub fn new(foo_: T) -> Self { + Wrapper(Foo(foo_)) + } +} + +impl<T> Wrapper<Bar<T>> { + pub fn new(bar_: T) -> Self { + Wrapper(Bar(bar_)) + } +} + +fn main() { + let a = Wrapper::<Foo<f32>>::new(1.0); + let b = Wrapper::<Bar<f32>>::new(1.0); + (a, b); + //^^^^^^ (Wrapper<Foo<f32>>, Wrapper<Bar<f32>>) +} +"#, + ); +} + +#[test] +fn method_resolution_overloaded_const() { + cov_mark::check!(const_candidate_self_type_mismatch); + check_types( + r#" +struct Wrapper<T>(T); +struct Foo<T>(T); +struct Bar<T>(T); + +impl<T> Wrapper<Foo<T>> { + pub const VALUE: Foo<T>; +} + +impl<T> Wrapper<Bar<T>> { + pub const VALUE: Bar<T>; +} + +fn main() { + let a = Wrapper::<Foo<f32>>::VALUE; + let b = Wrapper::<Bar<f32>>::VALUE; + (a, b); + //^^^^^^ (Foo<f32>, Bar<f32>) +} +"#, + ); +} + +#[test] +fn method_resolution_encountering_fn_type() { + check_types( + r#" +//- /main.rs +fn foo() {} +trait FnOnce { fn call(self); } +fn test() { foo.call(); } + //^^^^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn super_trait_impl_return_trait_method_resolution() { + check_infer( + r#" + //- minicore: sized + trait Base { + fn foo(self) -> usize; + } + + trait Super : Base {} + + fn base1() -> impl Base { loop {} } + fn super1() -> impl Super { loop {} } + + fn test(base2: impl Base, super2: impl Super) { + base1().foo(); + super1().foo(); + base2.foo(); + super2.foo(); + } + "#, + expect![[r#" + 24..28 'self': Self + 90..101 '{ loop {} }': ! + 92..99 'loop {}': ! + 97..99 '{}': () + 128..139 '{ loop {} }': ! + 130..137 'loop {}': ! + 135..137 '{}': () + 149..154 'base2': impl Base + 167..173 'super2': impl Super + 187..264 '{ ...o(); }': () + 193..198 'base1': fn base1() -> impl Base + 193..200 'base1()': impl Base + 193..206 'base1().foo()': usize + 212..218 'super1': fn super1() -> impl Super + 212..220 'super1()': impl Super + 212..226 'super1().foo()': usize + 232..237 'base2': impl Base + 232..243 'base2.foo()': usize + 249..255 'super2': impl Super + 249..261 'super2.foo()': usize + "#]], + ); +} + +#[test] +fn method_resolution_non_parameter_type() { + check_types( + r#" +mod a { + pub trait Foo { + fn foo(&self); + } +} + +struct Wrapper<T>(T); +fn foo<T>(t: Wrapper<T>) +where + Wrapper<T>: a::Foo, +{ + t.foo(); +} //^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn method_resolution_3373() { + check_types( + r#" +struct A<T>(T); + +impl A<i32> { + fn from(v: i32) -> A<i32> { A(v) } +} + +fn main() { + A::from(3); +} //^^^^^^^^^^ A<i32> +"#, + ); +} + +#[test] +fn method_resolution_slow() { + // this can get quite slow if we set the solver size limit too high + check_types( + r#" +trait SendX {} + +struct S1; impl SendX for S1 {} +struct S2; impl SendX for S2 {} +struct U1; + +trait Trait { fn method(self); } + +struct X1<A, B> {} +impl<A, B> SendX for X1<A, B> where A: SendX, B: SendX {} + +struct S<B, C> {} + +trait FnX {} + +impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {} + +fn test() { (S {}).method(); } + //^^^^^^^^^^^^^^^ () +"#, + ); +} + +#[test] +fn dyn_trait_super_trait_not_in_scope() { + check_infer( + r#" + mod m { + pub trait SuperTrait { + fn foo(&self) -> u32 { 0 } + } + } + trait Trait: m::SuperTrait {} + + struct S; + impl m::SuperTrait for S {} + impl Trait for S {} + + fn test(d: &dyn Trait) { + d.foo(); + } + "#, + expect![[r#" + 51..55 'self': &Self + 64..69 '{ 0 }': u32 + 66..67 '0': u32 + 176..177 'd': &dyn Trait + 191..207 '{ ...o(); }': () + 197..198 'd': &dyn Trait + 197..204 'd.foo()': u32 + "#]], + ); +} + +#[test] +fn method_resolution_foreign_opaque_type() { + check_infer( + r#" +extern "C" { + type S; + fn f() -> &'static S; +} + +impl S { + fn foo(&self) -> bool { + true + } +} + +fn test() { + let s = unsafe { f() }; + s.foo(); +} +"#, + expect![[r#" + 75..79 'self': &S + 89..109 '{ ... }': bool + 99..103 'true': bool + 123..167 '{ ...o(); }': () + 133..134 's': &S + 137..151 'unsafe { f() }': &S + 137..151 'unsafe { f() }': &S + 146..147 'f': fn f() -> &S + 146..149 'f()': &S + 157..158 's': &S + 157..164 's.foo()': bool + "#]], + ); +} + +#[test] +fn method_with_allocator_box_self_type() { + check_types( + r#" +struct Slice<T> {} +struct Box<T, A> {} + +impl<T> Slice<T> { + pub fn into_vec<A>(self: Box<Self, A>) { } +} + +fn main() { + let foo: Slice<u32>; + foo.into_vec(); // we shouldn't crash on this at least +} //^^^^^^^^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn method_on_dyn_impl() { + check_types( + r#" +trait Foo {} + +impl Foo for u32 {} +impl dyn Foo + '_ { + pub fn dyn_foo(&self) -> u32 { + 0 + } +} + +fn main() { + let f = &42u32 as &dyn Foo; + f.dyn_foo(); + // ^^^^^^^^^^^ u32 +} +"#, + ); +} + +#[test] +fn autoderef_visibility_field() { + check( + r#" +//- minicore: deref +mod a { + pub struct Foo(pub char); + pub struct Bar(i32); + impl Bar { + pub fn new() -> Self { + Self(0) + } + } + impl core::ops::Deref for Bar { + type Target = Foo; + fn deref(&self) -> &Foo { + &Foo('z') + } + } +} +mod b { + fn foo() { + let x = super::a::Bar::new().0; + // ^^^^^^^^^^^^^^^^^^^^ adjustments: Deref(Some(OverloadedDeref(Not))) + // ^^^^^^^^^^^^^^^^^^^^^^ type: char + } +} +"#, + ) +} + +#[test] +fn autoderef_visibility_method() { + cov_mark::check!(autoderef_candidate_not_visible); + check( + r#" +//- minicore: deref +mod a { + pub struct Foo(pub char); + impl Foo { + pub fn mango(&self) -> char { + self.0 + } + } + pub struct Bar(i32); + impl Bar { + pub fn new() -> Self { + Self(0) + } + fn mango(&self) -> i32 { + self.0 + } + } + impl core::ops::Deref for Bar { + type Target = Foo; + fn deref(&self) -> &Foo { + &Foo('z') + } + } +} +mod b { + fn foo() { + let x = super::a::Bar::new().mango(); + // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type: char + } +} +"#, + ) +} + +#[test] +fn trait_vs_private_inherent_const() { + cov_mark::check!(const_candidate_not_visible); + check( + r#" +mod a { + pub struct Foo; + impl Foo { + const VALUE: u32 = 2; + } + pub trait Trait { + const VALUE: usize; + } + impl Trait for Foo { + const VALUE: usize = 3; + } + + fn foo() { + let x = Foo::VALUE; + // ^^^^^^^^^^ type: u32 + } +} +use a::Trait; +fn foo() { + let x = a::Foo::VALUE; + // ^^^^^^^^^^^^^ type: usize +} +"#, + ) +} + +#[test] +fn trait_impl_in_unnamed_const() { + check_types( + r#" +struct S; + +trait Tr { + fn method(&self) -> u16; +} + +const _: () = { + impl Tr for S {} +}; + +fn f() { + S.method(); + //^^^^^^^^^^ u16 +} + "#, + ); +} + +#[test] +fn trait_impl_in_synstructure_const() { + check_types( + r#" +struct S; + +trait Tr { + fn method(&self) -> u16; +} + +const _DERIVE_Tr_: () = { + impl Tr for S {} +}; + +fn f() { + S.method(); + //^^^^^^^^^^ u16 +} + "#, + ); +} + +#[test] +fn inherent_impl_in_unnamed_const() { + check_types( + r#" +struct S; + +const _: () = { + impl S { + fn method(&self) -> u16 { 0 } + + pub(super) fn super_method(&self) -> u16 { 0 } + + pub(crate) fn crate_method(&self) -> u16 { 0 } + + pub fn pub_method(&self) -> u16 { 0 } + } +}; + +fn f() { + S.method(); + //^^^^^^^^^^ u16 + + S.super_method(); + //^^^^^^^^^^^^^^^^ u16 + + S.crate_method(); + //^^^^^^^^^^^^^^^^ u16 + + S.pub_method(); + //^^^^^^^^^^^^^^ u16 +} + "#, + ); +} + +#[test] +fn resolve_const_generic_array_methods() { + check_types( + r#" +#[lang = "array"] +impl<T, const N: usize> [T; N] { + pub fn map<F, U>(self, f: F) -> [U; N] + where + F: FnMut(T) -> U, + { loop {} } +} + +#[lang = "slice"] +impl<T> [T] { + pub fn map<F, U>(self, f: F) -> &[U] + where + F: FnMut(T) -> U, + { loop {} } +} + +fn f() { + let v = [1, 2].map::<_, usize>(|x| -> x * 2); + v; + //^ [usize; 2] +} + "#, + ); +} + +#[test] +fn resolve_const_generic_method() { + check_types( + r#" +struct Const<const N: usize>; + +#[lang = "array"] +impl<T, const N: usize> [T; N] { + pub fn my_map<F, U, const X: usize>(self, f: F, c: Const<X>) -> [U; X] + where + F: FnMut(T) -> U, + { loop {} } +} + +#[lang = "slice"] +impl<T> [T] { + pub fn my_map<F, const X: usize, U>(self, f: F, c: Const<X>) -> &[U] + where + F: FnMut(T) -> U, + { loop {} } +} + +fn f<const C: usize, P>() { + let v = [1, 2].my_map::<_, (), 12>(|x| -> x * 2, Const::<12>); + v; + //^ [(); 12] + let v = [1, 2].my_map::<_, P, C>(|x| -> x * 2, Const::<C>); + v; + //^ [P; C] +} + "#, + ); +} + +#[test] +fn const_generic_type_alias() { + check_types( + r#" +struct Const<const N: usize>; +type U2 = Const<2>; +type U5 = Const<5>; + +impl U2 { + fn f(self) -> Const<12> { + loop {} + } +} + +impl U5 { + fn f(self) -> Const<15> { + loop {} + } +} + +fn f(x: U2) { + let y = x.f(); + //^ Const<12> +} + "#, + ); +} + +#[test] +fn skip_array_during_method_dispatch() { + check_types( + r#" +//- /main2018.rs crate:main2018 deps:core +use core::IntoIterator; + +fn f() { + let v = [4].into_iter(); + v; + //^ &i32 + + let a = [0, 1].into_iter(); + a; + //^ &i32 +} + +//- /main2021.rs crate:main2021 deps:core edition:2021 +use core::IntoIterator; + +fn f() { + let v = [4].into_iter(); + v; + //^ i32 + + let a = [0, 1].into_iter(); + a; + //^ &i32 +} + +//- /core.rs crate:core +#[rustc_skip_array_during_method_dispatch] +pub trait IntoIterator { + type Out; + fn into_iter(self) -> Self::Out; +} + +impl<T> IntoIterator for [T; 1] { + type Out = T; + fn into_iter(self) -> Self::Out { loop {} } +} +impl<'a, T> IntoIterator for &'a [T] { + type Out = &'a T; + fn into_iter(self) -> Self::Out { loop {} } +} + "#, + ); +} + +#[test] +fn sized_blanket_impl() { + check_infer( + r#" +//- minicore: sized +trait Foo { fn foo() -> u8; } +impl<T: Sized> Foo for T {} +fn f<S: Sized, T, U: ?Sized>() { + u32::foo; + S::foo; + T::foo; + U::foo; + <[u32]>::foo; +} +"#, + expect![[r#" + 89..160 '{ ...foo; }': () + 95..103 'u32::foo': fn foo<u32>() -> u8 + 109..115 'S::foo': fn foo<S>() -> u8 + 121..127 'T::foo': fn foo<T>() -> u8 + 133..139 'U::foo': {unknown} + 145..157 '<[u32]>::foo': {unknown} + "#]], + ); +} + +#[test] +fn local_impl() { + check_types( + r#" +fn main() { + struct SomeStruct(i32); + + impl SomeStruct { + fn is_even(&self) -> bool { + self.0 % 2 == 0 + } + } + + let o = SomeStruct(3); + let is_even = o.is_even(); + // ^^^^^^^ bool +} + "#, + ); +} + +#[test] +fn deref_fun_1() { + check_types( + r#" +//- minicore: deref + +struct A<T, U>(T, U); +struct B<T>(T); +struct C<T>(T); + +impl<T> core::ops::Deref for A<B<T>, u32> { + type Target = B<T>; + fn deref(&self) -> &B<T> { &self.0 } +} +impl core::ops::Deref for B<isize> { + type Target = C<isize>; + fn deref(&self) -> &C<isize> { loop {} } +} + +impl<T: Copy> C<T> { + fn thing(&self) -> T { self.0 } +} + +fn make<T>() -> T { loop {} } + +fn test() { + let a1 = A(make(), make()); + let _: usize = (*a1).0; + a1; + //^^ A<B<usize>, u32> + + let a2 = A(make(), make()); + a2.thing(); + //^^^^^^^^^^ isize + a2; + //^^ A<B<isize>, u32> +} +"#, + ); +} + +#[test] +fn deref_fun_2() { + check_types( + r#" +//- minicore: deref + +struct A<T, U>(T, U); +struct B<T>(T); +struct C<T>(T); + +impl<T> core::ops::Deref for A<B<T>, u32> { + type Target = B<T>; + fn deref(&self) -> &B<T> { &self.0 } +} +impl core::ops::Deref for B<isize> { + type Target = C<isize>; + fn deref(&self) -> &C<isize> { loop {} } +} + +impl<T> core::ops::Deref for A<C<T>, i32> { + type Target = C<T>; + fn deref(&self) -> &C<T> { &self.0 } +} + +impl<T: Copy> C<T> { + fn thing(&self) -> T { self.0 } +} + +fn make<T>() -> T { loop {} } + +fn test() { + let a1 = A(make(), 1u32); + a1.thing(); + a1; + //^^ A<B<isize>, u32> + + let a2 = A(make(), 1i32); + let _: &str = a2.thing(); + a2; + //^^ A<C<&str>, i32> +} +"#, + ); +} + +#[test] +fn receiver_adjustment_autoref() { + check( + r#" +struct Foo; +impl Foo { + fn foo(&self) {} +} +fn test() { + Foo.foo(); + //^^^ adjustments: Borrow(Ref(Not)) + (&Foo).foo(); + // ^^^^ adjustments: , +} +"#, + ); +} + +#[test] +fn receiver_adjustment_unsize_array() { + // FIXME not quite correct + check( + r#" +//- minicore: slice +fn test() { + let a = [1, 2, 3]; + a.len(); +} //^ adjustments: Pointer(Unsize), Borrow(Ref(Not)) +"#, + ); +} + +#[test] +fn bad_inferred_reference_1() { + check_no_mismatches( + r#" +//- minicore: sized +pub trait Into<T>: Sized { + fn into(self) -> T; +} +impl<T> Into<T> for T { + fn into(self) -> T { self } +} + +trait ExactSizeIterator { + fn len(&self) -> usize; +} + +pub struct Foo; +impl Foo { + fn len(&self) -> usize { 0 } +} + +pub fn test(generic_args: impl Into<Foo>) { + let generic_args = generic_args.into(); + generic_args.len(); + let _: Foo = generic_args; +} +"#, + ); +} + +#[test] +fn bad_inferred_reference_2() { + check_no_mismatches( + r#" +//- minicore: deref +trait ExactSizeIterator { + fn len(&self) -> usize; +} + +pub struct Foo; +impl Foo { + fn len(&self) -> usize { 0 } +} + +pub fn test() { + let generic_args; + generic_args.len(); + let _: Foo = generic_args; +} +"#, + ); +} + +#[test] +fn resolve_minicore_iterator() { + check_types( + r#" +//- minicore: iterators, sized +fn foo() { + let m = core::iter::repeat(()).filter_map(|()| Some(92)).next(); +} //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Option<i32> +"#, + ); +} + +#[test] +fn primitive_assoc_fn_shadowed_by_use() { + check_types( + r#" +//- /lib.rs crate:lib deps:core +use core::u16; + +fn f() -> u16 { + let x = u16::from_le_bytes(); + x + //^ u16 +} + +//- /core.rs crate:core +pub mod u16 {} + +impl u16 { + pub fn from_le_bytes() -> Self { 0 } +} + "#, + ) +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs new file mode 100644 index 000000000..fbdc8209f --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs @@ -0,0 +1,485 @@ +use expect_test::expect; + +use super::{check_infer_with_mismatches, check_no_mismatches, check_types}; + +#[test] +fn infer_never1() { + check_types( + r#" +fn test() { + let t = return; + t; +} //^ ! +"#, + ); +} + +#[test] +fn infer_never2() { + check_types( + r#" +fn gen<T>() -> T { loop {} } + +fn test() { + let a = gen(); + if false { a } else { loop {} }; + a; +} //^ ! +"#, + ); +} + +#[test] +fn infer_never3() { + check_types( + r#" +fn gen<T>() -> T { loop {} } + +fn test() { + let a = gen(); + if false { loop {} } else { a }; + a; + //^ ! +} +"#, + ); +} + +#[test] +fn never_type_in_generic_args() { + check_types( + r#" +enum Option<T> { None, Some(T) } + +fn test() { + let a = if true { Option::None } else { Option::Some(return) }; + a; +} //^ Option<!> +"#, + ); +} + +#[test] +fn never_type_can_be_reinferred1() { + check_types( + r#" +fn gen<T>() -> T { loop {} } + +fn test() { + let a = gen(); + if false { loop {} } else { a }; + a; + //^ () + if false { a }; +} +"#, + ); +} + +#[test] +fn never_type_can_be_reinferred2() { + check_types( + r#" +enum Option<T> { None, Some(T) } + +fn test() { + let a = if true { Option::None } else { Option::Some(return) }; + a; + //^ Option<i32> + match 42 { + 42 => a, + _ => Option::Some(42), + }; +} +"#, + ); +} + +#[test] +fn never_type_can_be_reinferred3() { + check_types( + r#" +enum Option<T> { None, Some(T) } + +fn test() { + let a = if true { Option::None } else { Option::Some(return) }; + a; + //^ Option<&str> + match 42 { + 42 => a, + _ => Option::Some("str"), + }; +} +"#, + ); +} + +#[test] +fn match_no_arm() { + check_types( + r#" +enum Void {} + +fn test(a: Void) { + let t = match a {}; + t; +} //^ ! +"#, + ); +} + +#[test] +fn match_unknown_arm() { + check_types( + r#" +fn test(a: Option) { + let t = match 0 { + _ => unknown, + }; + t; +} //^ {unknown} +"#, + ); +} + +#[test] +fn if_never() { + check_types( + r#" +fn test() { + let i = if true { + loop {} + } else { + 3.0 + }; + i; +} //^ f64 +"#, + ); +} + +#[test] +fn if_else_never() { + check_types( + r#" +fn test(input: bool) { + let i = if input { + 2.0 + } else { + return + }; + i; +} //^ f64 +"#, + ); +} + +#[test] +fn match_first_arm_never() { + check_types( + r#" +fn test(a: i32) { + let i = match a { + 1 => return, + 2 => 2.0, + 3 => loop {}, + _ => 3.0, + }; + i; +} //^ f64 +"#, + ); +} + +#[test] +fn match_second_arm_never() { + check_types( + r#" +fn test(a: i32) { + let i = match a { + 1 => 3.0, + 2 => loop {}, + 3 => 3.0, + _ => return, + }; + i; +} //^ f64 +"#, + ); +} + +#[test] +fn match_all_arms_never() { + check_types( + r#" +fn test(a: i32) { + let i = match a { + 2 => return, + _ => loop {}, + }; + i; +} //^ ! +"#, + ); +} + +#[test] +fn match_no_never_arms() { + check_types( + r#" +fn test(a: i32) { + let i = match a { + 2 => 2.0, + _ => 3.0, + }; + i; +} //^ f64 +"#, + ); +} + +#[test] +fn diverging_expression_1() { + check_infer_with_mismatches( + r" + //- /main.rs + fn test1() { + let x: u32 = return; + } + fn test2() { + let x: u32 = { return; }; + } + fn test3() { + let x: u32 = loop {}; + } + fn test4() { + let x: u32 = { loop {} }; + } + fn test5() { + let x: u32 = { if true { loop {}; } else { loop {}; } }; + } + fn test6() { + let x: u32 = { let y: u32 = { loop {}; }; }; + } + ", + expect![[r" + 11..39 '{ ...urn; }': () + 21..22 'x': u32 + 30..36 'return': ! + 51..84 '{ ...; }; }': () + 61..62 'x': u32 + 70..81 '{ return; }': u32 + 72..78 'return': ! + 96..125 '{ ... {}; }': () + 106..107 'x': u32 + 115..122 'loop {}': ! + 120..122 '{}': () + 137..170 '{ ...} }; }': () + 147..148 'x': u32 + 156..167 '{ loop {} }': u32 + 158..165 'loop {}': ! + 163..165 '{}': () + 182..246 '{ ...} }; }': () + 192..193 'x': u32 + 201..243 '{ if t...}; } }': u32 + 203..241 'if tru... {}; }': u32 + 206..210 'true': bool + 211..223 '{ loop {}; }': u32 + 213..220 'loop {}': ! + 218..220 '{}': () + 229..241 '{ loop {}; }': u32 + 231..238 'loop {}': ! + 236..238 '{}': () + 258..310 '{ ...; }; }': () + 268..269 'x': u32 + 277..307 '{ let ...; }; }': u32 + 283..284 'y': u32 + 292..304 '{ loop {}; }': u32 + 294..301 'loop {}': ! + 299..301 '{}': () + "]], + ); +} + +#[test] +fn diverging_expression_2() { + check_infer_with_mismatches( + r#" + //- /main.rs + fn test1() { + // should give type mismatch + let x: u32 = { loop {}; "foo" }; + } + "#, + expect![[r#" + 11..84 '{ ..." }; }': () + 54..55 'x': u32 + 63..81 '{ loop...foo" }': u32 + 65..72 'loop {}': ! + 70..72 '{}': () + 74..79 '"foo"': &str + 74..79: expected u32, got &str + "#]], + ); +} + +#[test] +fn diverging_expression_3_break() { + check_infer_with_mismatches( + r" + //- /main.rs + fn test1() { + // should give type mismatch + let x: u32 = { loop { break; } }; + } + fn test2() { + // should give type mismatch + let x: u32 = { for a in b { break; }; }; + // should give type mismatch as well + let x: u32 = { for a in b {}; }; + // should give type mismatch as well + let x: u32 = { for a in b { return; }; }; + } + fn test3() { + // should give type mismatch + let x: u32 = { while true { break; }; }; + // should give type mismatch as well -- there's an implicit break, even if it's never hit + let x: u32 = { while true {}; }; + // should give type mismatch as well + let x: u32 = { while true { return; }; }; + } + ", + expect![[r#" + 11..85 '{ ...} }; }': () + 54..55 'x': u32 + 63..82 '{ loop...k; } }': u32 + 65..80 'loop { break; }': () + 70..80 '{ break; }': () + 72..77 'break': ! + 65..80: expected u32, got () + 97..343 '{ ...; }; }': () + 140..141 'x': u32 + 149..175 '{ for ...; }; }': u32 + 151..172 'for a ...eak; }': () + 155..156 'a': {unknown} + 160..161 'b': {unknown} + 162..172 '{ break; }': () + 164..169 'break': ! + 226..227 'x': u32 + 235..253 '{ for ... {}; }': u32 + 237..250 'for a in b {}': () + 241..242 'a': {unknown} + 246..247 'b': {unknown} + 248..250 '{}': () + 304..305 'x': u32 + 313..340 '{ for ...; }; }': u32 + 315..337 'for a ...urn; }': () + 319..320 'a': {unknown} + 324..325 'b': {unknown} + 326..337 '{ return; }': () + 328..334 'return': ! + 149..175: expected u32, got () + 235..253: expected u32, got () + 313..340: expected u32, got () + 355..654 '{ ...; }; }': () + 398..399 'x': u32 + 407..433 '{ whil...; }; }': u32 + 409..430 'while ...eak; }': () + 415..419 'true': bool + 420..430 '{ break; }': () + 422..427 'break': ! + 537..538 'x': u32 + 546..564 '{ whil... {}; }': u32 + 548..561 'while true {}': () + 554..558 'true': bool + 559..561 '{}': () + 615..616 'x': u32 + 624..651 '{ whil...; }; }': u32 + 626..648 'while ...urn; }': () + 632..636 'true': bool + 637..648 '{ return; }': () + 639..645 'return': ! + 407..433: expected u32, got () + 546..564: expected u32, got () + 624..651: expected u32, got () + "#]], + ); +} + +#[test] +fn let_else_must_diverge() { + check_infer_with_mismatches( + r#" + fn f() { + let 1 = 2 else { + return; + }; + } + "#, + expect![[r#" + 7..54 '{ ... }; }': () + 17..18 '1': i32 + 17..18 '1': i32 + 21..22 '2': i32 + 28..51 '{ ... }': ! + 38..44 'return': ! + "#]], + ); + check_infer_with_mismatches( + r#" + fn f() { + let 1 = 2 else {}; + } + "#, + expect![[r#" + 7..33 '{ ... {}; }': () + 17..18 '1': i32 + 17..18 '1': i32 + 21..22 '2': i32 + 28..30 '{}': ! + 28..30: expected !, got () + "#]], + ); +} + +#[test] +fn issue_11837() { + check_no_mismatches( + r#" +//- minicore: result +enum MyErr { + Err1, + Err2, +} + +fn example_ng() { + let value: Result<i32, MyErr> = Ok(3); + + loop { + let ret = match value { + Ok(value) => value, + Err(ref err) => { + match err { + MyErr::Err1 => break, + MyErr::Err2 => continue, + }; + } + }; + } +} +"#, + ); +} + +#[test] +fn issue_11814() { + check_no_mismatches( + r#" +fn example() -> bool { + match 1 { + _ => return true, + }; +} +"#, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs new file mode 100644 index 000000000..399553356 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs @@ -0,0 +1,991 @@ +use expect_test::expect; + +use super::{check, check_infer, check_infer_with_mismatches, check_types}; + +#[test] +fn infer_pattern() { + check_infer( + r#" + fn test(x: &i32) { + let y = x; + let &z = x; + let a = z; + let (c, d) = (1, "hello"); + + for (e, f) in some_iter { + let g = e; + } + + if let [val] = opt { + let h = val; + } + + if let x @ true = &true {} + + let lambda = |a: u64, b, c: i32| { a + b; c }; + + let ref ref_to_x = x; + let mut mut_x = x; + let ref mut mut_ref_to_x = x; + let k = mut_ref_to_x; + } + "#, + expect![[r#" + 8..9 'x': &i32 + 17..400 '{ ...o_x; }': () + 27..28 'y': &i32 + 31..32 'x': &i32 + 42..44 '&z': &i32 + 43..44 'z': i32 + 47..48 'x': &i32 + 58..59 'a': i32 + 62..63 'z': i32 + 73..79 '(c, d)': (i32, &str) + 74..75 'c': i32 + 77..78 'd': &str + 82..94 '(1, "hello")': (i32, &str) + 83..84 '1': i32 + 86..93 '"hello"': &str + 101..151 'for (e... }': () + 105..111 '(e, f)': ({unknown}, {unknown}) + 106..107 'e': {unknown} + 109..110 'f': {unknown} + 115..124 'some_iter': {unknown} + 125..151 '{ ... }': () + 139..140 'g': {unknown} + 143..144 'e': {unknown} + 157..204 'if let... }': () + 160..175 'let [val] = opt': bool + 164..169 '[val]': [{unknown}] + 165..168 'val': {unknown} + 172..175 'opt': [{unknown}] + 176..204 '{ ... }': () + 190..191 'h': {unknown} + 194..197 'val': {unknown} + 210..236 'if let...rue {}': () + 213..233 'let x ... &true': bool + 217..225 'x @ true': &bool + 221..225 'true': bool + 221..225 'true': bool + 228..233 '&true': &bool + 229..233 'true': bool + 234..236 '{}': () + 246..252 'lambda': |u64, u64, i32| -> i32 + 255..287 '|a: u6...b; c }': |u64, u64, i32| -> i32 + 256..257 'a': u64 + 264..265 'b': u64 + 267..268 'c': i32 + 275..287 '{ a + b; c }': i32 + 277..278 'a': u64 + 277..282 'a + b': u64 + 281..282 'b': u64 + 284..285 'c': i32 + 298..310 'ref ref_to_x': &&i32 + 313..314 'x': &i32 + 324..333 'mut mut_x': &i32 + 336..337 'x': &i32 + 347..367 'ref mu...f_to_x': &mut &i32 + 370..371 'x': &i32 + 381..382 'k': &mut &i32 + 385..397 'mut_ref_to_x': &mut &i32 + "#]], + ); +} + +#[test] +fn infer_literal_pattern() { + check_infer_with_mismatches( + r#" + fn any<T>() -> T { loop {} } + fn test(x: &i32) { + if let "foo" = any() {} + if let 1 = any() {} + if let 1u32 = any() {} + if let 1f32 = any() {} + if let 1.0 = any() {} + if let true = any() {} + } + "#, + expect![[r#" + 17..28 '{ loop {} }': T + 19..26 'loop {}': ! + 24..26 '{}': () + 37..38 'x': &i32 + 46..208 '{ ...) {} }': () + 52..75 'if let...y() {}': () + 55..72 'let "f... any()': bool + 59..64 '"foo"': &str + 59..64 '"foo"': &str + 67..70 'any': fn any<&str>() -> &str + 67..72 'any()': &str + 73..75 '{}': () + 80..99 'if let...y() {}': () + 83..96 'let 1 = any()': bool + 87..88 '1': i32 + 87..88 '1': i32 + 91..94 'any': fn any<i32>() -> i32 + 91..96 'any()': i32 + 97..99 '{}': () + 104..126 'if let...y() {}': () + 107..123 'let 1u... any()': bool + 111..115 '1u32': u32 + 111..115 '1u32': u32 + 118..121 'any': fn any<u32>() -> u32 + 118..123 'any()': u32 + 124..126 '{}': () + 131..153 'if let...y() {}': () + 134..150 'let 1f... any()': bool + 138..142 '1f32': f32 + 138..142 '1f32': f32 + 145..148 'any': fn any<f32>() -> f32 + 145..150 'any()': f32 + 151..153 '{}': () + 158..179 'if let...y() {}': () + 161..176 'let 1.0 = any()': bool + 165..168 '1.0': f64 + 165..168 '1.0': f64 + 171..174 'any': fn any<f64>() -> f64 + 171..176 'any()': f64 + 177..179 '{}': () + 184..206 'if let...y() {}': () + 187..203 'let tr... any()': bool + 191..195 'true': bool + 191..195 'true': bool + 198..201 'any': fn any<bool>() -> bool + 198..203 'any()': bool + 204..206 '{}': () + "#]], + ); +} + +#[test] +fn infer_range_pattern() { + check_infer_with_mismatches( + r#" + fn test(x: &i32) { + if let 1..76 = 2u32 {} + if let 1..=76 = 2u32 {} + } + "#, + expect![[r#" + 8..9 'x': &i32 + 17..75 '{ ...2 {} }': () + 23..45 'if let...u32 {}': () + 26..42 'let 1....= 2u32': bool + 30..35 '1..76': u32 + 38..42 '2u32': u32 + 43..45 '{}': () + 50..73 'if let...u32 {}': () + 53..70 'let 1....= 2u32': bool + 57..63 '1..=76': u32 + 66..70 '2u32': u32 + 71..73 '{}': () + "#]], + ); +} + +#[test] +fn infer_pattern_match_ergonomics() { + check_infer( + r#" + struct A<T>(T); + + fn test() { + let A(n) = &A(1); + let A(n) = &mut A(1); + } + "#, + expect![[r#" + 27..78 '{ ...(1); }': () + 37..41 'A(n)': A<i32> + 39..40 'n': &i32 + 44..49 '&A(1)': &A<i32> + 45..46 'A': A<i32>(i32) -> A<i32> + 45..49 'A(1)': A<i32> + 47..48 '1': i32 + 59..63 'A(n)': A<i32> + 61..62 'n': &mut i32 + 66..75 '&mut A(1)': &mut A<i32> + 71..72 'A': A<i32>(i32) -> A<i32> + 71..75 'A(1)': A<i32> + 73..74 '1': i32 + "#]], + ); +} + +#[test] +fn infer_pattern_match_ergonomics_ref() { + cov_mark::check!(match_ergonomics_ref); + check_infer( + r#" + fn test() { + let v = &(1, &2); + let (_, &w) = v; + } + "#, + expect![[r#" + 10..56 '{ ...= v; }': () + 20..21 'v': &(i32, &i32) + 24..32 '&(1, &2)': &(i32, &i32) + 25..32 '(1, &2)': (i32, &i32) + 26..27 '1': i32 + 29..31 '&2': &i32 + 30..31 '2': i32 + 42..49 '(_, &w)': (i32, &i32) + 43..44 '_': i32 + 46..48 '&w': &i32 + 47..48 'w': i32 + 52..53 'v': &(i32, &i32) + "#]], + ); +} + +#[test] +fn infer_pattern_match_slice() { + check_infer( + r#" + fn test() { + let slice: &[f64] = &[0.0]; + match slice { + &[] => {}, + &[a] => { + a; + }, + &[b, c] => { + b; + c; + } + _ => {} + } + } + "#, + expect![[r#" + 10..209 '{ ... } }': () + 20..25 'slice': &[f64] + 36..42 '&[0.0]': &[f64; 1] + 37..42 '[0.0]': [f64; 1] + 38..41 '0.0': f64 + 48..207 'match ... }': () + 54..59 'slice': &[f64] + 70..73 '&[]': &[f64] + 71..73 '[]': [f64] + 77..79 '{}': () + 89..93 '&[a]': &[f64] + 90..93 '[a]': [f64] + 91..92 'a': f64 + 97..123 '{ ... }': () + 111..112 'a': f64 + 133..140 '&[b, c]': &[f64] + 134..140 '[b, c]': [f64] + 135..136 'b': f64 + 138..139 'c': f64 + 144..185 '{ ... }': () + 158..159 'b': f64 + 173..174 'c': f64 + 194..195 '_': &[f64] + 199..201 '{}': () + "#]], + ); +} + +#[test] +fn infer_pattern_match_string_literal() { + check_infer_with_mismatches( + r#" + fn test() { + let s: &str = "hello"; + match s { + "hello" => {} + _ => {} + } + } + "#, + expect![[r#" + 10..98 '{ ... } }': () + 20..21 's': &str + 30..37 '"hello"': &str + 43..96 'match ... }': () + 49..50 's': &str + 61..68 '"hello"': &str + 61..68 '"hello"': &str + 72..74 '{}': () + 83..84 '_': &str + 88..90 '{}': () + "#]], + ); +} + +#[test] +fn infer_pattern_match_or() { + check_infer_with_mismatches( + r#" + fn test() { + let s: &str = "hello"; + match s { + "hello" | "world" => {} + _ => {} + } + } + "#, + expect![[r#" + 10..108 '{ ... } }': () + 20..21 's': &str + 30..37 '"hello"': &str + 43..106 'match ... }': () + 49..50 's': &str + 61..68 '"hello"': &str + 61..68 '"hello"': &str + 61..78 '"hello...world"': &str + 71..78 '"world"': &str + 71..78 '"world"': &str + 82..84 '{}': () + 93..94 '_': &str + 98..100 '{}': () + "#]], + ); +} + +#[test] +fn infer_pattern_match_arr() { + check_infer( + r#" + fn test() { + let arr: [f64; 2] = [0.0, 1.0]; + match arr { + [1.0, a] => { + a; + }, + [b, c] => { + b; + c; + } + } + } + "#, + expect![[r#" + 10..179 '{ ... } }': () + 20..23 'arr': [f64; 2] + 36..46 '[0.0, 1.0]': [f64; 2] + 37..40 '0.0': f64 + 42..45 '1.0': f64 + 52..177 'match ... }': () + 58..61 'arr': [f64; 2] + 72..80 '[1.0, a]': [f64; 2] + 73..76 '1.0': f64 + 73..76 '1.0': f64 + 78..79 'a': f64 + 84..110 '{ ... }': () + 98..99 'a': f64 + 120..126 '[b, c]': [f64; 2] + 121..122 'b': f64 + 124..125 'c': f64 + 130..171 '{ ... }': () + 144..145 'b': f64 + 159..160 'c': f64 + "#]], + ); +} + +#[test] +fn infer_adt_pattern() { + check_infer( + r#" + enum E { + A { x: usize }, + B + } + + struct S(u32, E); + + fn test() { + let e = E::A { x: 3 }; + + let S(y, z) = foo; + let E::A { x: new_var } = e; + + match e { + E::A { x } => x, + E::B if foo => 1, + E::B => 10, + }; + + let ref d @ E::A { .. } = e; + d; + } + "#, + expect![[r#" + 67..288 '{ ... d; }': () + 77..78 'e': E + 81..94 'E::A { x: 3 }': E + 91..92 '3': usize + 105..112 'S(y, z)': S + 107..108 'y': u32 + 110..111 'z': E + 115..118 'foo': S + 128..147 'E::A {..._var }': E + 138..145 'new_var': usize + 150..151 'e': E + 158..244 'match ... }': usize + 164..165 'e': E + 176..186 'E::A { x }': E + 183..184 'x': usize + 190..191 'x': usize + 201..205 'E::B': E + 209..212 'foo': bool + 216..217 '1': usize + 227..231 'E::B': E + 235..237 '10': usize + 255..274 'ref d ...{ .. }': &E + 263..274 'E::A { .. }': E + 277..278 'e': E + 284..285 'd': &E + "#]], + ); +} + +#[test] +fn enum_variant_through_self_in_pattern() { + check_infer( + r#" + enum E { + A { x: usize }, + B(usize), + C + } + + impl E { + fn test() { + match (loop {}) { + Self::A { x } => { x; }, + Self::B(x) => { x; }, + Self::C => {}, + }; + } + } + "#, + expect![[r#" + 75..217 '{ ... }': () + 85..210 'match ... }': () + 92..99 'loop {}': ! + 97..99 '{}': () + 115..128 'Self::A { x }': E + 125..126 'x': usize + 132..138 '{ x; }': () + 134..135 'x': usize + 152..162 'Self::B(x)': E + 160..161 'x': usize + 166..172 '{ x; }': () + 168..169 'x': usize + 186..193 'Self::C': E + 197..199 '{}': () + "#]], + ); +} + +#[test] +fn infer_generics_in_patterns() { + check_infer( + r#" + struct A<T> { + x: T, + } + + enum Option<T> { + Some(T), + None, + } + + fn test(a1: A<u32>, o: Option<u64>) { + let A { x: x2 } = a1; + let A::<i64> { x: x3 } = A { x: 1 }; + match o { + Option::Some(t) => t, + _ => 1, + }; + } + "#, + expect![[r#" + 78..80 'a1': A<u32> + 90..91 'o': Option<u64> + 106..243 '{ ... }; }': () + 116..127 'A { x: x2 }': A<u32> + 123..125 'x2': u32 + 130..132 'a1': A<u32> + 142..160 'A::<i6...: x3 }': A<i64> + 156..158 'x3': i64 + 163..173 'A { x: 1 }': A<i64> + 170..171 '1': i64 + 179..240 'match ... }': u64 + 185..186 'o': Option<u64> + 197..212 'Option::Some(t)': Option<u64> + 210..211 't': u64 + 216..217 't': u64 + 227..228 '_': Option<u64> + 232..233 '1': u64 + "#]], + ); +} + +#[test] +fn infer_const_pattern() { + check( + r#" +enum Option<T> { None } +use Option::None; +struct Foo; +const Bar: usize = 1; + +fn test() { + let a: Option<u32> = None; + let b: Option<i64> = match a { + None => None, + }; + let _: () = match () { Foo => () }; + // ^^^ expected (), got Foo + let _: () = match () { Bar => () }; + // ^^^ expected (), got usize +} + "#, + ); +} + +#[test] +fn infer_guard() { + check_infer( + r#" +struct S; +impl S { fn foo(&self) -> bool { false } } + +fn main() { + match S { + s if s.foo() => (), + } +} + "#, + expect![[r#" + 27..31 'self': &S + 41..50 '{ false }': bool + 43..48 'false': bool + 64..115 '{ ... } }': () + 70..113 'match ... }': () + 76..77 'S': S + 88..89 's': S + 93..94 's': S + 93..100 's.foo()': bool + 104..106 '()': () + "#]], + ) +} + +#[test] +fn match_ergonomics_in_closure_params() { + check_infer( + r#" +//- minicore: fn +fn foo<T, U, F: FnOnce(T) -> U>(t: T, f: F) -> U { loop {} } + +fn test() { + foo(&(1, "a"), |&(x, y)| x); // normal, no match ergonomics + foo(&(1, "a"), |(x, y)| x); +} +"#, + expect![[r#" + 32..33 't': T + 38..39 'f': F + 49..60 '{ loop {} }': U + 51..58 'loop {}': ! + 56..58 '{}': () + 72..171 '{ ... x); }': () + 78..81 'foo': fn foo<&(i32, &str), i32, |&(i32, &str)| -> i32>(&(i32, &str), |&(i32, &str)| -> i32) -> i32 + 78..105 'foo(&(...y)| x)': i32 + 82..91 '&(1, "a")': &(i32, &str) + 83..91 '(1, "a")': (i32, &str) + 84..85 '1': i32 + 87..90 '"a"': &str + 93..104 '|&(x, y)| x': |&(i32, &str)| -> i32 + 94..101 '&(x, y)': &(i32, &str) + 95..101 '(x, y)': (i32, &str) + 96..97 'x': i32 + 99..100 'y': &str + 103..104 'x': i32 + 142..145 'foo': fn foo<&(i32, &str), &i32, |&(i32, &str)| -> &i32>(&(i32, &str), |&(i32, &str)| -> &i32) -> &i32 + 142..168 'foo(&(...y)| x)': &i32 + 146..155 '&(1, "a")': &(i32, &str) + 147..155 '(1, "a")': (i32, &str) + 148..149 '1': i32 + 151..154 '"a"': &str + 157..167 '|(x, y)| x': |&(i32, &str)| -> &i32 + 158..164 '(x, y)': (i32, &str) + 159..160 'x': &i32 + 162..163 'y': &&str + 166..167 'x': &i32 + "#]], + ); +} + +#[test] +fn slice_tail_pattern() { + check_infer( + r#" + fn foo(params: &[i32]) { + match params { + [head, tail @ ..] => { + } + } + } + "#, + expect![[r#" + 7..13 'params': &[i32] + 23..92 '{ ... } }': () + 29..90 'match ... }': () + 35..41 'params': &[i32] + 52..69 '[head,... @ ..]': [i32] + 53..57 'head': &i32 + 59..68 'tail @ ..': &[i32] + 66..68 '..': [i32] + 73..84 '{ }': () + "#]], + ); +} + +#[test] +fn box_pattern() { + check_infer( + r#" + pub struct Global; + #[lang = "owned_box"] + pub struct Box<T, A = Global>(T); + + fn foo(params: Box<i32>) { + match params { + box integer => {} + } + } + "#, + expect![[r#" + 83..89 'params': Box<i32, Global> + 101..155 '{ ... } }': () + 107..153 'match ... }': () + 113..119 'params': Box<i32, Global> + 130..141 'box integer': Box<i32, Global> + 134..141 'integer': i32 + 145..147 '{}': () + "#]], + ); + check_infer( + r#" + #[lang = "owned_box"] + pub struct Box<T>(T); + + fn foo(params: Box<i32>) { + match params { + box integer => {} + } + } + "#, + expect![[r#" + 52..58 'params': Box<i32> + 70..124 '{ ... } }': () + 76..122 'match ... }': () + 82..88 'params': Box<i32> + 99..110 'box integer': Box<i32> + 103..110 'integer': i32 + 114..116 '{}': () + "#]], + ); +} + +#[test] +fn tuple_ellipsis_pattern() { + check_infer_with_mismatches( + r#" +fn foo(tuple: (u8, i16, f32)) { + match tuple { + (.., b, c) => {}, + (a, .., c) => {}, + (a, b, ..) => {}, + (a, b) => {/*too short*/} + (a, b, c, d) => {/*too long*/} + _ => {} + } +}"#, + expect![[r#" + 7..12 'tuple': (u8, i16, f32) + 30..224 '{ ... } }': () + 36..222 'match ... }': () + 42..47 'tuple': (u8, i16, f32) + 58..68 '(.., b, c)': (u8, i16, f32) + 63..64 'b': i16 + 66..67 'c': f32 + 72..74 '{}': () + 84..94 '(a, .., c)': (u8, i16, f32) + 85..86 'a': u8 + 92..93 'c': f32 + 98..100 '{}': () + 110..120 '(a, b, ..)': (u8, i16, f32) + 111..112 'a': u8 + 114..115 'b': i16 + 124..126 '{}': () + 136..142 '(a, b)': (u8, i16) + 137..138 'a': u8 + 140..141 'b': i16 + 146..161 '{/*too short*/}': () + 170..182 '(a, b, c, d)': (u8, i16, f32, {unknown}) + 171..172 'a': u8 + 174..175 'b': i16 + 177..178 'c': f32 + 180..181 'd': {unknown} + 186..200 '{/*too long*/}': () + 209..210 '_': (u8, i16, f32) + 214..216 '{}': () + 136..142: expected (u8, i16, f32), got (u8, i16) + 170..182: expected (u8, i16, f32), got (u8, i16, f32, {unknown}) + "#]], + ); +} + +#[test] +fn tuple_struct_ellipsis_pattern() { + check_infer( + r#" +struct Tuple(u8, i16, f32); +fn foo(tuple: Tuple) { + match tuple { + Tuple(.., b, c) => {}, + Tuple(a, .., c) => {}, + Tuple(a, b, ..) => {}, + Tuple(a, b) => {/*too short*/} + Tuple(a, b, c, d) => {/*too long*/} + _ => {} + } +}"#, + expect![[r#" + 35..40 'tuple': Tuple + 49..268 '{ ... } }': () + 55..266 'match ... }': () + 61..66 'tuple': Tuple + 77..92 'Tuple(.., b, c)': Tuple + 87..88 'b': i16 + 90..91 'c': f32 + 96..98 '{}': () + 108..123 'Tuple(a, .., c)': Tuple + 114..115 'a': u8 + 121..122 'c': f32 + 127..129 '{}': () + 139..154 'Tuple(a, b, ..)': Tuple + 145..146 'a': u8 + 148..149 'b': i16 + 158..160 '{}': () + 170..181 'Tuple(a, b)': Tuple + 176..177 'a': u8 + 179..180 'b': i16 + 185..200 '{/*too short*/}': () + 209..226 'Tuple(... c, d)': Tuple + 215..216 'a': u8 + 218..219 'b': i16 + 221..222 'c': f32 + 224..225 'd': {unknown} + 230..244 '{/*too long*/}': () + 253..254 '_': Tuple + 258..260 '{}': () + "#]], + ); +} + +#[test] +fn const_block_pattern() { + check_infer( + r#" +struct Foo(usize); +fn foo(foo: Foo) { + match foo { + const { Foo(15 + 32) } => {}, + _ => {} + } +}"#, + expect![[r#" + 26..29 'foo': Foo + 36..115 '{ ... } }': () + 42..113 'match ... }': () + 48..51 'foo': Foo + 62..84 'const ... 32) }': Foo + 68..84 '{ Foo(... 32) }': Foo + 70..73 'Foo': Foo(usize) -> Foo + 70..82 'Foo(15 + 32)': Foo + 74..76 '15': usize + 74..81 '15 + 32': usize + 79..81 '32': usize + 88..90 '{}': () + 100..101 '_': Foo + 105..107 '{}': () + "#]], + ); +} + +#[test] +fn macro_pat() { + check_types( + r#" +macro_rules! pat { + ($name:ident) => { Enum::Variant1($name) } +} + +enum Enum { + Variant1(u8), + Variant2, +} + +fn f(e: Enum) { + match e { + pat!(bind) => { + bind; + //^^^^ u8 + } + Enum::Variant2 => {} + } +} + "#, + ) +} + +#[test] +fn type_mismatch_in_or_pattern() { + check_infer_with_mismatches( + r#" +fn main() { + match (false,) { + (true | (),) => {} + (() | true,) => {} + (_ | (),) => {} + (() | _,) => {} + } +} +"#, + expect![[r#" + 10..142 '{ ... } }': () + 16..140 'match ... }': () + 22..30 '(false,)': (bool,) + 23..28 'false': bool + 41..53 '(true | (),)': (bool,) + 42..46 'true': bool + 42..46 'true': bool + 42..51 'true | ()': bool + 49..51 '()': () + 57..59 '{}': () + 68..80 '(() | true,)': ((),) + 69..71 '()': () + 69..78 '() | true': () + 74..78 'true': bool + 74..78 'true': bool + 84..86 '{}': () + 95..104 '(_ | (),)': (bool,) + 96..97 '_': bool + 96..102 '_ | ()': bool + 100..102 '()': () + 108..110 '{}': () + 119..128 '(() | _,)': ((),) + 120..122 '()': () + 120..126 '() | _': () + 125..126 '_': bool + 132..134 '{}': () + 49..51: expected bool, got () + 68..80: expected (bool,), got ((),) + 69..71: expected bool, got () + 69..78: expected bool, got () + 100..102: expected bool, got () + 119..128: expected (bool,), got ((),) + 120..122: expected bool, got () + 120..126: expected bool, got () + "#]], + ); +} + +#[test] +fn slice_pattern_correctly_handles_array_length() { + check_infer( + r#" +fn main() { + let [head, middle @ .., tail, tail2] = [1, 2, 3, 4, 5]; +} + "#, + expect![[r#" + 10..73 '{ ... 5]; }': () + 20..52 '[head,...tail2]': [i32; 5] + 21..25 'head': i32 + 27..38 'middle @ ..': [i32; 2] + 36..38 '..': [i32; 2] + 40..44 'tail': i32 + 46..51 'tail2': i32 + 55..70 '[1, 2, 3, 4, 5]': [i32; 5] + 56..57 '1': i32 + 59..60 '2': i32 + 62..63 '3': i32 + 65..66 '4': i32 + 68..69 '5': i32 + "#]], + ); +} + +#[test] +fn pattern_lookup_in_value_ns() { + check_types( + r#" +use self::Constructor::*; +struct IntRange { + range: (), +} +enum Constructor { + IntRange(IntRange), +} +fn main() { + match Constructor::IntRange(IntRange { range: () }) { + IntRange(x) => { + x; + //^ IntRange + } + Constructor::IntRange(x) => { + x; + //^ IntRange + } + } +} + "#, + ); +} + +#[test] +fn if_let_guards() { + check_types( + r#" +fn main() { + match (0,) { + opt if let (x,) = opt => { + x; + //^ i32 + } + _ => {} + } +} + "#, + ); +} + +#[test] +fn tuple_wildcard() { + check_types( + r#" +fn main() { + enum Option<T> {Some(T), None} + use Option::*; + + let mut x = None; + x; + //^ Option<(i32, i32)> + + if let Some((_, _a)) = x {} + + x = Some((1, 2)); +} + "#, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs new file mode 100644 index 000000000..93a88ab58 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs @@ -0,0 +1,1650 @@ +use expect_test::expect; + +use super::{check_infer, check_no_mismatches, check_types}; + +#[test] +fn bug_484() { + check_infer( + r#" + fn test() { + let x = if true {}; + } + "#, + expect![[r#" + 10..37 '{ ... {}; }': () + 20..21 'x': () + 24..34 'if true {}': () + 27..31 'true': bool + 32..34 '{}': () + "#]], + ); +} + +#[test] +fn no_panic_on_field_of_enum() { + check_infer( + r#" + enum X {} + + fn test(x: X) { + x.some_field; + } + "#, + expect![[r#" + 19..20 'x': X + 25..46 '{ ...eld; }': () + 31..32 'x': X + 31..43 'x.some_field': {unknown} + "#]], + ); +} + +#[test] +fn bug_585() { + check_infer( + r#" + fn test() { + X {}; + match x { + A::B {} => (), + A::Y() => (), + } + } + "#, + expect![[r#" + 10..88 '{ ... } }': () + 16..20 'X {}': {unknown} + 26..86 'match ... }': () + 32..33 'x': {unknown} + 44..51 'A::B {}': {unknown} + 55..57 '()': () + 67..73 'A::Y()': {unknown} + 77..79 '()': () + "#]], + ); +} + +#[test] +fn bug_651() { + check_infer( + r#" + fn quux() { + let y = 92; + 1 + y; + } + "#, + expect![[r#" + 10..40 '{ ...+ y; }': () + 20..21 'y': i32 + 24..26 '92': i32 + 32..33 '1': i32 + 32..37 '1 + y': i32 + 36..37 'y': i32 + "#]], + ); +} + +#[test] +fn recursive_vars() { + check_infer( + r#" + fn test() { + let y = unknown; + [y, &y]; + } + "#, + expect![[r#" + 10..47 '{ ...&y]; }': () + 20..21 'y': {unknown} + 24..31 'unknown': {unknown} + 37..44 '[y, &y]': [{unknown}; 2] + 38..39 'y': {unknown} + 41..43 '&y': &{unknown} + 42..43 'y': {unknown} + "#]], + ); +} + +#[test] +fn recursive_vars_2() { + check_infer( + r#" + fn test() { + let x = unknown; + let y = unknown; + [(x, y), (&y, &x)]; + } + "#, + expect![[r#" + 10..79 '{ ...x)]; }': () + 20..21 'x': &{unknown} + 24..31 'unknown': &{unknown} + 41..42 'y': {unknown} + 45..52 'unknown': {unknown} + 58..76 '[(x, y..., &x)]': [(&{unknown}, {unknown}); 2] + 59..65 '(x, y)': (&{unknown}, {unknown}) + 60..61 'x': &{unknown} + 63..64 'y': {unknown} + 67..75 '(&y, &x)': (&{unknown}, {unknown}) + 68..70 '&y': &{unknown} + 69..70 'y': {unknown} + 72..74 '&x': &&{unknown} + 73..74 'x': &{unknown} + "#]], + ); +} + +#[test] +fn array_elements_expected_type() { + check_no_mismatches( + r#" + fn test() { + let x: [[u32; 2]; 2] = [[1, 2], [3, 4]]; + } + "#, + ); +} + +#[test] +fn infer_std_crash_1() { + // caused stack overflow, taken from std + check_infer( + r#" + enum Maybe<T> { + Real(T), + Fake, + } + + fn write() { + match something_unknown { + Maybe::Real(ref mut something) => (), + } + } + "#, + expect![[r#" + 53..138 '{ ... } }': () + 59..136 'match ... }': () + 65..82 'someth...nknown': Maybe<{unknown}> + 93..123 'Maybe:...thing)': Maybe<{unknown}> + 105..122 'ref mu...ething': &mut {unknown} + 127..129 '()': () + "#]], + ); +} + +#[test] +fn infer_std_crash_2() { + // caused "equating two type variables, ...", taken from std + check_infer( + r#" + fn test_line_buffer() { + &[0, b'\n', 1, b'\n']; + } + "#, + expect![[r#" + 22..52 '{ ...n']; }': () + 28..49 '&[0, b...b'\n']': &[u8; 4] + 29..49 '[0, b'...b'\n']': [u8; 4] + 30..31 '0': u8 + 33..38 'b'\n'': u8 + 40..41 '1': u8 + 43..48 'b'\n'': u8 + "#]], + ); +} + +#[test] +fn infer_std_crash_3() { + // taken from rustc + check_infer( + r#" + pub fn compute() { + match nope!() { + SizeSkeleton::Pointer { non_zero: true, tail } => {} + } + } + "#, + expect![[r#" + 17..107 '{ ... } }': () + 23..105 'match ... }': () + 29..36 'nope!()': {unknown} + 47..93 'SizeSk...tail }': {unknown} + 81..85 'true': bool + 81..85 'true': bool + 87..91 'tail': {unknown} + 97..99 '{}': () + "#]], + ); +} + +#[test] +fn infer_std_crash_4() { + // taken from rustc + check_infer( + r#" + pub fn primitive_type() { + match *self { + BorrowedRef { type_: Primitive(p), ..} => {}, + } + } + "#, + expect![[r#" + 24..105 '{ ... } }': () + 30..103 'match ... }': () + 36..41 '*self': {unknown} + 37..41 'self': {unknown} + 52..90 'Borrow...), ..}': {unknown} + 73..85 'Primitive(p)': {unknown} + 83..84 'p': {unknown} + 94..96 '{}': () + "#]], + ); +} + +#[test] +fn infer_std_crash_5() { + // taken from rustc + check_infer( + r#" + fn extra_compiler_flags() { + for content in doesnt_matter { + let name = if doesnt_matter { + first + } else { + &content + }; + + let content = if ICE_REPORT_COMPILER_FLAGS_STRIP_VALUE.contains(&name) { + name + } else { + content + }; + } + } + "#, + expect![[r#" + 26..322 '{ ... } }': () + 32..320 'for co... }': () + 36..43 'content': {unknown} + 47..60 'doesnt_matter': {unknown} + 61..320 '{ ... }': () + 75..79 'name': &{unknown} + 82..166 'if doe... }': &{unknown} + 85..98 'doesnt_matter': bool + 99..128 '{ ... }': &{unknown} + 113..118 'first': &{unknown} + 134..166 '{ ... }': &{unknown} + 148..156 '&content': &{unknown} + 149..156 'content': {unknown} + 181..188 'content': &{unknown} + 191..313 'if ICE... }': &{unknown} + 194..231 'ICE_RE..._VALUE': {unknown} + 194..247 'ICE_RE...&name)': bool + 241..246 '&name': &&{unknown} + 242..246 'name': &{unknown} + 248..276 '{ ... }': &{unknown} + 262..266 'name': &{unknown} + 282..313 '{ ... }': {unknown} + 296..303 'content': {unknown} + "#]], + ); +} + +#[test] +fn infer_nested_generics_crash() { + // another crash found typechecking rustc + check_infer( + r#" + struct Canonical<V> { + value: V, + } + struct QueryResponse<V> { + value: V, + } + fn test<R>(query_response: Canonical<QueryResponse<R>>) { + &query_response.value; + } + "#, + expect![[r#" + 91..105 'query_response': Canonical<QueryResponse<R>> + 136..166 '{ ...lue; }': () + 142..163 '&query....value': &QueryResponse<R> + 143..157 'query_response': Canonical<QueryResponse<R>> + 143..163 'query_....value': QueryResponse<R> + "#]], + ); +} + +#[test] +fn infer_paren_macro_call() { + check_infer( + r#" + macro_rules! bar { () => {0u32} } + fn test() { + let a = (bar!()); + } + "#, + expect![[r#" + !0..4 '0u32': u32 + 44..69 '{ ...()); }': () + 54..55 'a': u32 + "#]], + ); +} + +#[test] +fn infer_array_macro_call() { + check_infer( + r#" + macro_rules! bar { () => {0u32} } + fn test() { + let a = [bar!()]; + } + "#, + expect![[r#" + !0..4 '0u32': u32 + 44..69 '{ ...()]; }': () + 54..55 'a': [u32; 1] + 58..66 '[bar!()]': [u32; 1] + "#]], + ); +} + +#[test] +fn bug_1030() { + check_infer( + r#" + struct HashSet<T, H>; + struct FxHasher; + type FxHashSet<T> = HashSet<T, FxHasher>; + + impl<T, H> HashSet<T, H> { + fn default() -> HashSet<T, H> {} + } + + pub fn main_loop() { + FxHashSet::default(); + } + "#, + expect![[r#" + 143..145 '{}': HashSet<T, H> + 168..197 '{ ...t(); }': () + 174..192 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<{unknown}, FxHasher> + 174..194 'FxHash...ault()': HashSet<{unknown}, FxHasher> + "#]], + ); +} + +#[test] +fn issue_2669() { + check_infer( + r#" + trait A {} + trait Write {} + struct Response<T> {} + + trait D { + fn foo(); + } + + impl<T:A> D for Response<T> { + fn foo() { + end(); + fn end<W: Write>() { + let _x: T = loop {}; + } + } + } + "#, + expect![[r#" + 119..214 '{ ... }': () + 129..132 'end': fn end<{unknown}>() + 129..134 'end()': () + 163..208 '{ ... }': () + 181..183 '_x': ! + 190..197 'loop {}': ! + 195..197 '{}': () + "#]], + ) +} + +#[test] +fn issue_2705() { + check_infer( + r#" + trait Trait {} + fn test() { + <Trait<u32>>::foo() + } + "#, + expect![[r#" + 25..52 '{ ...oo() }': () + 31..48 '<Trait...>::foo': {unknown} + 31..50 '<Trait...:foo()': () + "#]], + ); +} + +#[test] +fn issue_2683_chars_impl() { + check_types( + r#" +//- minicore: iterator +pub struct Chars<'a> {} +impl<'a> Iterator for Chars<'a> { + type Item = char; + fn next(&mut self) -> Option<char> { loop {} } +} + +fn test() { + let chars: Chars<'_>; + (chars.next(), chars.nth(1)); +} //^^^^^^^^^^^^^^^^^^^^^^^^^^^^ (Option<char>, Option<char>) +"#, + ); +} + +#[test] +fn issue_3999_slice() { + check_infer( + r#" + fn foo(params: &[usize]) { + match params { + [ps @ .., _] => {} + } + } + "#, + expect![[r#" + 7..13 'params': &[usize] + 25..80 '{ ... } }': () + 31..78 'match ... }': () + 37..43 'params': &[usize] + 54..66 '[ps @ .., _]': [usize] + 55..62 'ps @ ..': &[usize] + 60..62 '..': [usize] + 64..65 '_': usize + 70..72 '{}': () + "#]], + ); +} + +#[test] +fn issue_3999_struct() { + // rust-analyzer should not panic on seeing this malformed + // record pattern. + check_infer( + r#" + struct Bar { + a: bool, + } + fn foo(b: Bar) { + match b { + Bar { a: .. } => {}, + } + } + "#, + expect![[r#" + 35..36 'b': Bar + 43..95 '{ ... } }': () + 49..93 'match ... }': () + 55..56 'b': Bar + 67..80 'Bar { a: .. }': Bar + 76..78 '..': bool + 84..86 '{}': () + "#]], + ); +} + +#[test] +fn issue_4235_name_conflicts() { + check_infer( + r#" + struct FOO {} + static FOO:FOO = FOO {}; + + impl FOO { + fn foo(&self) {} + } + + fn main() { + let a = &FOO; + a.foo(); + } + "#, + expect![[r#" + 31..37 'FOO {}': FOO + 63..67 'self': &FOO + 69..71 '{}': () + 85..119 '{ ...o(); }': () + 95..96 'a': &FOO + 99..103 '&FOO': &FOO + 100..103 'FOO': FOO + 109..110 'a': &FOO + 109..116 'a.foo()': () + "#]], + ); +} + +#[test] +fn issue_4465_dollar_crate_at_type() { + check_infer( + r#" + pub struct Foo {} + pub fn anything<T>() -> T { + loop {} + } + macro_rules! foo { + () => {{ + let r: $crate::Foo = anything(); + r + }}; + } + fn main() { + let _a = foo!(); + } + "#, + expect![[r#" + 44..59 '{ loop {} }': T + 50..57 'loop {}': ! + 55..57 '{}': () + !0..31 '{letr:...g();r}': Foo + !4..5 'r': Foo + !18..26 'anything': fn anything<Foo>() -> Foo + !18..28 'anything()': Foo + !29..30 'r': Foo + 163..187 '{ ...!(); }': () + 173..175 '_a': Foo + "#]], + ); +} + +#[test] +fn issue_6811() { + check_infer( + r#" + macro_rules! profile_function { + () => { + let _a = 1; + let _b = 1; + }; + } + fn main() { + profile_function!(); + } + "#, + expect![[r#" + !0..16 'let_a=...t_b=1;': () + !3..5 '_a': i32 + !6..7 '1': i32 + !11..13 '_b': i32 + !14..15 '1': i32 + 103..131 '{ ...!(); }': () + "#]], + ); +} + +#[test] +fn issue_4053_diesel_where_clauses() { + check_infer( + r#" + trait BoxedDsl<DB> { + type Output; + fn internal_into_boxed(self) -> Self::Output; + } + + struct SelectStatement<From, Select, Distinct, Where, Order, LimitOffset, GroupBy, Locking> { + order: Order, + } + + trait QueryFragment<DB: Backend> {} + + trait Into<T> { fn into(self) -> T; } + + impl<F, S, D, W, O, LOf, DB> BoxedDsl<DB> + for SelectStatement<F, S, D, W, O, LOf, G> + where + O: Into<dyn QueryFragment<DB>>, + { + type Output = XXX; + + fn internal_into_boxed(self) -> Self::Output { + self.order.into(); + } + } + "#, + expect![[r#" + 65..69 'self': Self + 267..271 'self': Self + 466..470 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}> + 488..522 '{ ... }': () + 498..502 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}> + 498..508 'self.order': O + 498..515 'self.o...into()': dyn QueryFragment<DB> + "#]], + ); +} + +#[test] +fn issue_4953() { + check_infer( + r#" + pub struct Foo(pub i64); + impl Foo { + fn test() -> Self { Self(0i64) } + } + "#, + expect![[r#" + 58..72 '{ Self(0i64) }': Foo + 60..64 'Self': Foo(i64) -> Foo + 60..70 'Self(0i64)': Foo + 65..69 '0i64': i64 + "#]], + ); + check_infer( + r#" + pub struct Foo<T>(pub T); + impl Foo<i64> { + fn test() -> Self { Self(0i64) } + } + "#, + expect![[r#" + 64..78 '{ Self(0i64) }': Foo<i64> + 66..70 'Self': Foo<i64>(i64) -> Foo<i64> + 66..76 'Self(0i64)': Foo<i64> + 71..75 '0i64': i64 + "#]], + ); +} + +#[test] +fn issue_4931() { + check_infer( + r#" + trait Div<T> { + type Output; + } + + trait CheckedDiv: Div<()> {} + + trait PrimInt: CheckedDiv<Output = ()> { + fn pow(self); + } + + fn check<T: PrimInt>(i: T) { + i.pow(); + } + "#, + expect![[r#" + 117..121 'self': Self + 148..149 'i': T + 154..170 '{ ...w(); }': () + 160..161 'i': T + 160..167 'i.pow()': () + "#]], + ); +} + +#[test] +fn issue_4885() { + check_infer( + r#" + //- minicore: coerce_unsized, future + use core::future::Future; + trait Foo<R> { + type Bar; + } + fn foo<R, K>(key: &K) -> impl Future<Output = K::Bar> + where + K: Foo<R>, + { + bar(key) + } + fn bar<R, K>(key: &K) -> impl Future<Output = K::Bar> + where + K: Foo<R>, + { + } + "#, + expect![[r#" + 70..73 'key': &K + 132..148 '{ ...key) }': impl Future<Output = <K as Foo<R>>::Bar> + 138..141 'bar': fn bar<R, K>(&K) -> impl Future<Output = <K as Foo<R>>::Bar> + 138..146 'bar(key)': impl Future<Output = <K as Foo<R>>::Bar> + 142..145 'key': &K + 162..165 'key': &K + 224..227 '{ }': () + "#]], + ); +} + +#[test] +fn issue_4800() { + check_infer( + r#" + trait Debug {} + + struct Foo<T>; + + type E1<T> = (T, T, T); + type E2<T> = E1<E1<E1<(T, T, T)>>>; + + impl Debug for Foo<E2<()>> {} + + struct Request; + + pub trait Future { + type Output; + } + + pub struct PeerSet<D>; + + impl<D> Service<Request> for PeerSet<D> + where + D: Discover, + D::Key: Debug, + { + type Error = (); + type Future = dyn Future<Output = Self::Error>; + + fn call(&mut self) -> Self::Future { + loop {} + } + } + + pub trait Discover { + type Key; + } + + pub trait Service<Request> { + type Error; + type Future: Future<Output = Self::Error>; + fn call(&mut self) -> Self::Future; + } + "#, + expect![[r#" + 379..383 'self': &mut PeerSet<D> + 401..424 '{ ... }': dyn Future<Output = ()> + 411..418 'loop {}': ! + 416..418 '{}': () + 575..579 'self': &mut Self + "#]], + ); +} + +#[test] +fn issue_4966() { + check_infer( + r#" + //- minicore: deref + pub trait IntoIterator { + type Item; + } + + struct Repeat<A> { element: A } + + struct Map<F> { f: F } + + struct Vec<T> {} + + impl<T> core::ops::Deref for Vec<T> { + type Target = [T]; + } + + fn from_iter<A, T: IntoIterator<Item = A>>(iter: T) -> Vec<A> {} + + fn main() { + let inner = Map { f: |_: &f64| 0.0 }; + + let repeat = Repeat { element: inner }; + + let vec = from_iter(repeat); + + vec.foo_bar(); + } + "#, + expect![[r#" + 225..229 'iter': T + 244..246 '{}': Vec<A> + 258..402 '{ ...r(); }': () + 268..273 'inner': Map<|&f64| -> f64> + 276..300 'Map { ... 0.0 }': Map<|&f64| -> f64> + 285..298 '|_: &f64| 0.0': |&f64| -> f64 + 286..287 '_': &f64 + 295..298 '0.0': f64 + 311..317 'repeat': Repeat<Map<|&f64| -> f64>> + 320..345 'Repeat...nner }': Repeat<Map<|&f64| -> f64>> + 338..343 'inner': Map<|&f64| -> f64> + 356..359 'vec': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>> + 362..371 'from_iter': fn from_iter<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>, Repeat<Map<|&f64| -> f64>>>(Repeat<Map<|&f64| -> f64>>) -> Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>> + 362..379 'from_i...epeat)': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>> + 372..378 'repeat': Repeat<Map<|&f64| -> f64>> + 386..389 'vec': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>> + 386..399 'vec.foo_bar()': {unknown} + "#]], + ); +} + +#[test] +fn issue_6628() { + check_infer( + r#" +//- minicore: fn +struct S<T>(); +impl<T> S<T> { + fn f(&self, _t: T) {} + fn g<F: FnOnce(&T)>(&self, _f: F) {} +} +fn main() { + let s = S(); + s.g(|_x| {}); + s.f(10); +} +"#, + expect![[r#" + 40..44 'self': &S<T> + 46..48 '_t': T + 53..55 '{}': () + 81..85 'self': &S<T> + 87..89 '_f': F + 94..96 '{}': () + 109..160 '{ ...10); }': () + 119..120 's': S<i32> + 123..124 'S': S<i32>() -> S<i32> + 123..126 'S()': S<i32> + 132..133 's': S<i32> + 132..144 's.g(|_x| {})': () + 136..143 '|_x| {}': |&i32| -> () + 137..139 '_x': &i32 + 141..143 '{}': () + 150..151 's': S<i32> + 150..157 's.f(10)': () + 154..156 '10': i32 + "#]], + ); +} + +#[test] +fn issue_6852() { + check_infer( + r#" +//- minicore: deref +use core::ops::Deref; + +struct BufWriter {} + +struct Mutex<T> {} +struct MutexGuard<'a, T> {} +impl<T> Mutex<T> { + fn lock(&self) -> MutexGuard<'_, T> {} +} +impl<'a, T: 'a> Deref for MutexGuard<'a, T> { + type Target = T; +} +fn flush(&self) { + let w: &Mutex<BufWriter>; + *(w.lock()); +} +"#, + expect![[r#" + 123..127 'self': &Mutex<T> + 150..152 '{}': MutexGuard<T> + 234..238 'self': &{unknown} + 240..290 '{ ...()); }': () + 250..251 'w': &Mutex<BufWriter> + 276..287 '*(w.lock())': BufWriter + 278..279 'w': &Mutex<BufWriter> + 278..286 'w.lock()': MutexGuard<BufWriter> + "#]], + ); +} + +#[test] +fn param_overrides_fn() { + check_types( + r#" + fn example(example: i32) { + fn f() {} + example; + //^^^^^^^ i32 + } + "#, + ) +} + +#[test] +fn lifetime_from_chalk_during_deref() { + check_types( + r#" +//- minicore: deref +struct Box<T: ?Sized> {} +impl<T: ?Sized> core::ops::Deref for Box<T> { + type Target = T; + + fn deref(&self) -> &Self::Target { + loop {} + } +} + +trait Iterator { + type Item; +} + +pub struct Iter<'a, T: 'a> { + inner: Box<dyn IterTrait<'a, T, Item = &'a T> + 'a>, +} + +trait IterTrait<'a, T: 'a>: Iterator<Item = &'a T> { + fn clone_box(&self); +} + +fn clone_iter<T>(s: Iter<T>) { + s.inner.clone_box(); + //^^^^^^^^^^^^^^^^^^^ () +} +"#, + ) +} + +#[test] +fn issue_8686() { + check_infer( + r#" +pub trait Try: FromResidual { + type Output; + type Residual; +} +pub trait FromResidual<R = <Self as Try>::Residual> { + fn from_residual(residual: R) -> Self; +} + +struct ControlFlow<B, C>; +impl<B, C> Try for ControlFlow<B, C> { + type Output = C; + type Residual = ControlFlow<B, !>; +} +impl<B, C> FromResidual for ControlFlow<B, C> { + fn from_residual(r: ControlFlow<B, !>) -> Self { ControlFlow } +} + +fn test() { + ControlFlow::from_residual(ControlFlow::<u32, !>); +} + "#, + expect![[r#" + 144..152 'residual': R + 365..366 'r': ControlFlow<B, !> + 395..410 '{ ControlFlow }': ControlFlow<B, C> + 397..408 'ControlFlow': ControlFlow<B, C> + 424..482 '{ ...!>); }': () + 430..456 'Contro...sidual': fn from_residual<ControlFlow<u32, {unknown}>, ControlFlow<u32, !>>(ControlFlow<u32, !>) -> ControlFlow<u32, {unknown}> + 430..479 'Contro...2, !>)': ControlFlow<u32, {unknown}> + 457..478 'Contro...32, !>': ControlFlow<u32, !> + "#]], + ); +} + +#[test] +fn cfg_tail() { + // https://github.com/rust-lang/rust-analyzer/issues/8378 + check_infer( + r#" + fn fake_tail(){ + { "first" } + #[cfg(never)] 9 + } + fn multiple_fake(){ + { "fake" } + { "fake" } + { "second" } + #[cfg(never)] { 11 } + #[cfg(never)] 12; + #[cfg(never)] 13 + } + fn no_normal_tail(){ + { "third" } + #[cfg(never)] 14; + #[cfg(never)] 15; + } + fn no_actual_tail(){ + { "fourth" }; + #[cfg(never)] 14; + #[cfg(never)] 15 + } + "#, + expect![[r#" + 14..53 '{ ...)] 9 }': () + 20..31 '{ "first" }': () + 22..29 '"first"': &str + 72..190 '{ ...] 13 }': () + 78..88 '{ "fake" }': &str + 80..86 '"fake"': &str + 93..103 '{ "fake" }': &str + 95..101 '"fake"': &str + 108..120 '{ "second" }': () + 110..118 '"second"': &str + 210..273 '{ ... 15; }': () + 216..227 '{ "third" }': () + 218..225 '"third"': &str + 293..357 '{ ...] 15 }': () + 299..311 '{ "fourth" }': &str + 301..309 '"fourth"': &str + "#]], + ) +} + +#[test] +fn impl_trait_in_option_9530() { + check_types( + r#" +//- minicore: sized +struct Option<T>; +impl<T> Option<T> { + fn unwrap(self) -> T { loop {} } +} +fn make() -> Option<impl Copy> { Option } +trait Copy {} +fn test() { + let o = make(); + o.unwrap(); + //^^^^^^^^^^ impl Copy +} + "#, + ) +} + +#[test] +fn bare_dyn_trait_binders_9639() { + check_no_mismatches( + r#" +//- minicore: fn, coerce_unsized +fn infix_parse<T, S>(_state: S, _level_code: &Fn(S)) -> T { + loop {} +} + +fn parse_arule() { + infix_parse((), &(|_recurse| ())) +} + "#, + ) +} + +#[test] +fn call_expected_type_closure() { + check_types( + r#" +//- minicore: fn, option + +fn map<T, U>(o: Option<T>, f: impl FnOnce(T) -> U) -> Option<U> { loop {} } +struct S { + field: u32 +} + +fn test() { + let o = Some(S { field: 2 }); + let _: Option<()> = map(o, |s| { s.field; }); + // ^^^^^^^ u32 +} + "#, + ); +} + +#[test] +fn coerce_diesel_panic() { + check_no_mismatches( + r#" +//- minicore: option + +trait TypeMetadata { + type MetadataLookup; +} + +pub struct Output<'a, T, DB> +where + DB: TypeMetadata, + DB::MetadataLookup: 'a, +{ + out: T, + metadata_lookup: Option<&'a DB::MetadataLookup>, +} + +impl<'a, T, DB: TypeMetadata> Output<'a, T, DB> { + pub fn new(out: T, metadata_lookup: &'a DB::MetadataLookup) -> Self { + Output { + out, + metadata_lookup: Some(metadata_lookup), + } + } +} + "#, + ); +} + +#[test] +fn bitslice_panic() { + check_no_mismatches( + r#" +//- minicore: option, deref + +pub trait BitView { + type Store; +} + +pub struct Lsb0; + +pub struct BitArray<V: BitView> { } + +pub struct BitSlice<T> { } + +impl<V: BitView> core::ops::Deref for BitArray<V> { + type Target = BitSlice<V::Store>; +} + +impl<T> BitSlice<T> { + pub fn split_first(&self) -> Option<(T, &Self)> { loop {} } +} + +fn multiexp_inner() { + let exp: &BitArray<Foo>; + exp.split_first(); +} + "#, + ); +} + +#[test] +fn macro_expands_to_impl_trait() { + check_no_mismatches( + r#" +trait Foo {} + +macro_rules! ty { + () => { + impl Foo + } +} + +fn foo(_: ty!()) {} + +fn bar() { + foo(()); +} + "#, + ) +} + +#[test] +fn nested_macro_in_fn_params() { + check_no_mismatches( + r#" +macro_rules! U32Inner { + () => { + u32 + }; +} + +macro_rules! U32 { + () => { + U32Inner!() + }; +} + +fn mamba(a: U32!(), p: u32) -> u32 { + a +} + "#, + ) +} + +#[test] +fn for_loop_block_expr_iterable() { + check_infer( + r#" +fn test() { + for _ in { let x = 0; } { + let y = 0; + } +} + "#, + expect![[r#" + 10..68 '{ ... } }': () + 16..66 'for _ ... }': () + 20..21 '_': {unknown} + 25..39 '{ let x = 0; }': () + 31..32 'x': i32 + 35..36 '0': i32 + 40..66 '{ ... }': () + 54..55 'y': i32 + 58..59 '0': i32 + "#]], + ); +} + +#[test] +fn while_loop_block_expr_iterable() { + check_infer( + r#" +fn test() { + while { true } { + let y = 0; + } +} + "#, + expect![[r#" + 10..59 '{ ... } }': () + 16..57 'while ... }': () + 22..30 '{ true }': bool + 24..28 'true': bool + 31..57 '{ ... }': () + 45..46 'y': i32 + 49..50 '0': i32 + "#]], + ); +} + +#[test] +fn bug_11242() { + // FIXME: wrong, should be u32 + check_types( + r#" +fn foo<A, B>() +where + A: IntoIterator<Item = u32>, + B: IntoIterator<Item = usize>, +{ + let _x: <A as IntoIterator>::Item; + // ^^ {unknown} +} + +pub trait Iterator { + type Item; +} + +pub trait IntoIterator { + type Item; + type IntoIter: Iterator<Item = Self::Item>; +} + +impl<I: Iterator> IntoIterator for I { + type Item = I::Item; + type IntoIter = I; +} +"#, + ); +} + +#[test] +fn bug_11659() { + check_no_mismatches( + r#" +struct LinkArray<const N: usize, LD>(LD); +fn f<const N: usize, LD>(x: LD) -> LinkArray<N, LD> { + let r = LinkArray::<N, LD>(x); + r +} + +fn test() { + let x = f::<2, i32>(5); + let y = LinkArray::<52, LinkArray<2, i32>>(x); +} + "#, + ); + check_no_mismatches( + r#" +struct LinkArray<LD, const N: usize>(LD); +fn f<const N: usize, LD>(x: LD) -> LinkArray<LD, N> { + let r = LinkArray::<LD, N>(x); + r +} + +fn test() { + let x = f::<i32, 2>(5); + let y = LinkArray::<LinkArray<i32, 2>, 52>(x); +} + "#, + ); +} + +#[test] +fn const_generic_error_tolerance() { + check_no_mismatches( + r#" +#[lang = "sized"] +pub trait Sized {} + +struct CT<const N: usize, T>(T); +struct TC<T, const N: usize>(T); +fn f<const N: usize, T>(x: T) -> (CT<N, T>, TC<T, N>) { + let l = CT::<N, T>(x); + let r = TC::<N, T>(x); + (l, r) +} + +trait TR1<const N: usize>; +trait TR2<const N: usize>; + +impl<const N: usize, T> TR1<N> for CT<N, T>; +impl<const N: usize, T> TR1<5> for TC<T, N>; +impl<const N: usize, T> TR2<N> for CT<T, N>; + +trait TR3<const N: usize> { + fn tr3(&self) -> &Self; +} + +impl<const N: usize, T> TR3<5> for TC<T, N> { + fn tr3(&self) -> &Self { + self + } +} + +impl<const N: usize, T> TR3<Item = 5> for TC<T, N> {} +impl<const N: usize, T> TR3<T> for TC<T, N> {} + +fn impl_trait<const N: usize>(inp: impl TR1<N>) {} +fn dyn_trait<const N: usize>(inp: &dyn TR2<N>) {} +fn impl_trait_bad<'a, const N: usize>(inp: impl TR1<i32>) -> impl TR1<'a, i32> {} +fn impl_trait_very_bad<const N: usize>(inp: impl TR1<Item = i32>) -> impl TR1<'a, Item = i32, 5, Foo = N> {} + +fn test() { + f::<2, i32>(5); + f::<2, 2>(5); + f(5); + f::<i32>(5); + CT::<52, CT<2, i32>>(x); + CT::<CT<2, i32>>(x); + impl_trait_bad(5); + impl_trait_bad(12); + TR3<5>::tr3(); + TR3<{ 2+3 }>::tr3(); + TC::<i32, 10>(5).tr3(); + TC::<i32, 20>(5).tr3(); + TC::<i32, i32>(5).tr3(); + TC::<i32, { 7 + 3 }>(5).tr3(); +} + "#, + ); +} + +#[test] +fn const_generic_impl_trait() { + check_no_mismatches( + r#" + //- minicore: from + + struct Foo<T, const M: usize>; + + trait Tr<T> { + fn f(T) -> Self; + } + + impl<T, const M: usize> Tr<[T; M]> for Foo<T, M> { + fn f(_: [T; M]) -> Self { + Self + } + } + + fn test() { + Foo::f([1, 2, 7, 10]); + } + "#, + ); +} + +#[test] +fn nalgebra_factorial() { + check_no_mismatches( + r#" + const FACTORIAL: [u128; 4] = [1, 1, 2, 6]; + + fn factorial(n: usize) -> u128 { + match FACTORIAL.get(n) { + Some(f) => *f, + None => panic!("{}! is greater than u128::MAX", n), + } + } + "#, + ) +} + +#[test] +fn regression_11688_1() { + check_no_mismatches( + r#" + pub struct Buffer<T>(T); + type Writer = Buffer<u8>; + impl<T> Buffer<T> { + fn extend_from_array<const N: usize>(&mut self, xs: &[T; N]) { + loop {} + } + } + trait Encode<S> { + fn encode(self, w: &mut Writer, s: &mut S); + } + impl<S> Encode<S> for u8 { + fn encode(self, w: &mut Writer, _: &mut S) { + w.extend_from_array(&self.to_le_bytes()); + } + } + "#, + ); +} + +#[test] +fn regression_11688_2() { + check_types( + r#" + union MaybeUninit<T> { + uninit: (), + value: T, + } + + impl<T> MaybeUninit<T> { + fn uninit_array<const LEN: usize>() -> [Self; LEN] { + loop {} + } + } + + fn main() { + let x = MaybeUninit::<i32>::uninit_array::<1>(); + //^ [MaybeUninit<i32>; 1] + } + "#, + ); +} + +#[test] +fn regression_11688_3() { + check_types( + r#" + //- minicore: iterator + struct Ar<T, const N: u8>(T); + fn f<const LEN: usize, T, const BASE: u8>( + num_zeros: usize, + ) -> dyn Iterator<Item = [Ar<T, BASE>; LEN]> { + loop {} + } + fn dynamic_programming() { + for board in f::<9, u8, 7>(1) { + //^^^^^ [Ar<u8, 7>; 9] + } + } + "#, + ); +} + +#[test] +fn regression_11688_4() { + check_types( + r#" + trait Bar<const C: usize> { + fn baz(&self) -> [i32; C]; + } + + fn foo(x: &dyn Bar<2>) { + x.baz(); + //^^^^^^^ [i32; 2] + } + "#, + ) +} + +#[test] +fn gat_crash_1() { + cov_mark::check!(ignore_gats); + check_no_mismatches( + r#" +trait ATrait {} + +trait Crash { + type Member<const N: usize>: ATrait; + fn new<const N: usize>() -> Self::Member<N>; +} + +fn test<T: Crash>() { + T::new(); +} +"#, + ); +} + +#[test] +fn gat_crash_2() { + check_no_mismatches( + r#" +pub struct InlineStorage {} + +pub struct InlineStorageHandle<T: ?Sized> {} + +pub unsafe trait Storage { + type Handle<T: ?Sized>; + fn create<T: ?Sized>() -> Self::Handle<T>; +} + +unsafe impl Storage for InlineStorage { + type Handle<T: ?Sized> = InlineStorageHandle<T>; +} +"#, + ); +} + +#[test] +fn cfgd_out_self_param() { + cov_mark::check!(cfgd_out_self_param); + check_no_mismatches( + r#" +struct S; +impl S { + fn f(#[cfg(never)] &self) {} +} + +fn f(s: S) { + s.f(); +} +"#, + ); +} + +#[test] +fn rust_161_option_clone() { + check_types( + r#" +//- minicore: option, drop + +fn test(o: &Option<i32>) { + o.my_clone(); + //^^^^^^^^^^^^ Option<i32> +} + +pub trait MyClone: Sized { + fn my_clone(&self) -> Self; +} + +impl<T> const MyClone for Option<T> +where + T: ~const MyClone + ~const Drop + ~const Destruct, +{ + fn my_clone(&self) -> Self { + match self { + Some(x) => Some(x.my_clone()), + None => None, + } + } +} + +impl const MyClone for i32 { + fn my_clone(&self) -> Self { + *self + } +} + +pub trait Destruct {} + +impl<T: ?Sized> const Destruct for T {} +"#, + ); +} + +#[test] +fn rust_162_option_clone() { + check_types( + r#" +//- minicore: option, drop + +fn test(o: &Option<i32>) { + o.my_clone(); + //^^^^^^^^^^^^ Option<i32> +} + +pub trait MyClone: Sized { + fn my_clone(&self) -> Self; +} + +impl<T> const MyClone for Option<T> +where + T: ~const MyClone + ~const Destruct, +{ + fn my_clone(&self) -> Self { + match self { + Some(x) => Some(x.my_clone()), + None => None, + } + } +} + +impl const MyClone for i32 { + fn my_clone(&self) -> Self { + *self + } +} + +#[lang = "destruct"] +pub trait Destruct {} +"#, + ); +} + +#[test] +fn tuple_struct_pattern_with_unmatched_args_crash() { + check_infer( + r#" +struct S(usize); +fn main() { + let S(.., a, b) = S(1); + let (.., a, b) = (1,); +} + "#, + expect![[r#" + 27..85 '{ ...1,); }': () + 37..48 'S(.., a, b)': S + 43..44 'a': usize + 46..47 'b': {unknown} + 51..52 'S': S(usize) -> S + 51..55 'S(1)': S + 53..54 '1': usize + 65..75 '(.., a, b)': (i32, {unknown}) + 70..71 'a': i32 + 73..74 'b': {unknown} + 78..82 '(1,)': (i32,) + 79..80 '1': i32 + "#]], + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs new file mode 100644 index 000000000..5b08f5521 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs @@ -0,0 +1,3072 @@ +use expect_test::expect; + +use super::{check, check_infer, check_no_mismatches, check_types}; + +#[test] +fn infer_box() { + check_types( + r#" +//- /main.rs crate:main deps:std +fn test() { + let x = box 1; + let t = (x, box x, box &1, box [1]); + t; +} //^ (Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32; 1]>) + +//- /std.rs crate:std +#[prelude_import] use prelude::*; +mod prelude {} + +mod boxed { + #[lang = "owned_box"] + pub struct Box<T: ?Sized> { + inner: *mut T, + } +} +"#, + ); +} + +#[test] +fn infer_box_with_allocator() { + check_types( + r#" +//- /main.rs crate:main deps:std +fn test() { + let x = box 1; + let t = (x, box x, box &1, box [1]); + t; +} //^ (Box<i32, {unknown}>, Box<Box<i32, {unknown}>, {unknown}>, Box<&i32, {unknown}>, Box<[i32; 1], {unknown}>) + +//- /std.rs crate:std +#[prelude_import] use prelude::*; +mod boxed { + #[lang = "owned_box"] + pub struct Box<T: ?Sized, A: Allocator> { + inner: *mut T, + allocator: A, + } +} +"#, + ); +} + +#[test] +fn infer_adt_self() { + check_types( + r#" +enum Nat { Succ(Self), Demo(Nat), Zero } + +fn test() { + let foo: Nat = Nat::Zero; + if let Nat::Succ(x) = foo { + x; + } //^ Nat +} +"#, + ); +} + +#[test] +fn self_in_struct_lit() { + check_infer( + r#" + //- /main.rs + struct S<T> { x: T } + + impl S<u32> { + fn foo() { + Self { x: 1 }; + } + } + "#, + expect![[r#" + 49..79 '{ ... }': () + 59..72 'Self { x: 1 }': S<u32> + 69..70 '1': u32 + "#]], + ); +} + +#[test] +fn type_alias_in_struct_lit() { + check_infer( + r#" + //- /main.rs + struct S<T> { x: T } + + type SS = S<u32>; + + fn foo() { + SS { x: 1 }; + } + "#, + expect![[r#" + 50..70 '{ ...1 }; }': () + 56..67 'SS { x: 1 }': S<u32> + 64..65 '1': u32 + "#]], + ); +} + +#[test] +fn infer_ranges() { + check_types( + r#" +//- minicore: range +fn test() { + let a = ..; + let b = 1..; + let c = ..2u32; + let d = 1..2usize; + let e = ..=10; + let f = 'a'..='z'; + + let t = (a, b, c, d, e, f); + t; +} //^ (RangeFull, RangeFrom<i32>, RangeTo<u32>, Range<usize>, RangeToInclusive<i32>, RangeInclusive<char>) +"#, + ); +} + +#[test] +fn infer_while_let() { + check_types( + r#" +enum Option<T> { Some(T), None } + +fn test() { + let foo: Option<f32> = None; + while let Option::Some(x) = foo { + x; + } //^ f32 +} +"#, + ); +} + +#[test] +fn infer_basics() { + check_infer( + r#" +fn test(a: u32, b: isize, c: !, d: &str) { + a; + b; + c; + d; + 1usize; + 1isize; + "test"; + 1.0f32; +} +"#, + expect![[r#" + 8..9 'a': u32 + 16..17 'b': isize + 26..27 'c': ! + 32..33 'd': &str + 41..120 '{ ...f32; }': () + 47..48 'a': u32 + 54..55 'b': isize + 61..62 'c': ! + 68..69 'd': &str + 75..81 '1usize': usize + 87..93 '1isize': isize + 99..105 '"test"': &str + 111..117 '1.0f32': f32 + "#]], + ); +} + +#[test] +fn infer_let() { + check_infer( + r#" +fn test() { + let a = 1isize; + let b: usize = 1; + let c = b; + let d: u32; + let e; + let f: i32 = e; +} +"#, + expect![[r#" + 10..117 '{ ...= e; }': () + 20..21 'a': isize + 24..30 '1isize': isize + 40..41 'b': usize + 51..52 '1': usize + 62..63 'c': usize + 66..67 'b': usize + 77..78 'd': u32 + 93..94 'e': i32 + 104..105 'f': i32 + 113..114 'e': i32 + "#]], + ); +} + +#[test] +fn infer_paths() { + check_infer( + r#" +fn a() -> u32 { 1 } + +mod b { + fn c() -> u32 { 1 } +} + +fn test() { + a(); + b::c(); +} +"#, + expect![[r#" + 14..19 '{ 1 }': u32 + 16..17 '1': u32 + 47..52 '{ 1 }': u32 + 49..50 '1': u32 + 66..90 '{ ...c(); }': () + 72..73 'a': fn a() -> u32 + 72..75 'a()': u32 + 81..85 'b::c': fn c() -> u32 + 81..87 'b::c()': u32 + "#]], + ); +} + +#[test] +fn infer_path_type() { + check_infer( + r#" +struct S; + +impl S { + fn foo() -> i32 { 1 } +} + +fn test() { + S::foo(); + <S>::foo(); +} +"#, + expect![[r#" + 40..45 '{ 1 }': i32 + 42..43 '1': i32 + 59..92 '{ ...o(); }': () + 65..71 'S::foo': fn foo() -> i32 + 65..73 'S::foo()': i32 + 79..87 '<S>::foo': fn foo() -> i32 + 79..89 '<S>::foo()': i32 + "#]], + ); +} + +#[test] +fn infer_struct() { + check_infer( + r#" +struct A { + b: B, + c: C, +} +struct B; +struct C(usize); + +fn test() { + let c = C(1); + B; + let a: A = A { b: B, c: C(1) }; + a.b; + a.c; +} +"#, + expect![[r#" + 71..153 '{ ...a.c; }': () + 81..82 'c': C + 85..86 'C': C(usize) -> C + 85..89 'C(1)': C + 87..88 '1': usize + 95..96 'B': B + 106..107 'a': A + 113..132 'A { b:...C(1) }': A + 120..121 'B': B + 126..127 'C': C(usize) -> C + 126..130 'C(1)': C + 128..129 '1': usize + 138..139 'a': A + 138..141 'a.b': B + 147..148 'a': A + 147..150 'a.c': C + "#]], + ); +} + +#[test] +fn infer_enum() { + check_infer( + r#" +enum E { + V1 { field: u32 }, + V2 +} +fn test() { + E::V1 { field: 1 }; + E::V2; +} +"#, + expect![[r#" + 51..89 '{ ...:V2; }': () + 57..75 'E::V1 ...d: 1 }': E + 72..73 '1': u32 + 81..86 'E::V2': E + "#]], + ); +} + +#[test] +fn infer_union() { + check_infer( + r#" +union MyUnion { + foo: u32, + bar: f32, +} + +fn test() { + let u = MyUnion { foo: 0 }; + unsafe { baz(u); } + let u = MyUnion { bar: 0.0 }; + unsafe { baz(u); } +} + +unsafe fn baz(u: MyUnion) { + let inner = u.foo; + let inner = u.bar; +} +"#, + expect![[r#" + 57..172 '{ ...); } }': () + 67..68 'u': MyUnion + 71..89 'MyUnio...o: 0 }': MyUnion + 86..87 '0': u32 + 95..113 'unsafe...(u); }': () + 95..113 'unsafe...(u); }': () + 104..107 'baz': fn baz(MyUnion) + 104..110 'baz(u)': () + 108..109 'u': MyUnion + 122..123 'u': MyUnion + 126..146 'MyUnio... 0.0 }': MyUnion + 141..144 '0.0': f32 + 152..170 'unsafe...(u); }': () + 152..170 'unsafe...(u); }': () + 161..164 'baz': fn baz(MyUnion) + 161..167 'baz(u)': () + 165..166 'u': MyUnion + 188..189 'u': MyUnion + 200..249 '{ ...bar; }': () + 210..215 'inner': u32 + 218..219 'u': MyUnion + 218..223 'u.foo': u32 + 233..238 'inner': f32 + 241..242 'u': MyUnion + 241..246 'u.bar': f32 + "#]], + ); +} + +#[test] +fn infer_refs() { + check_infer( + r#" +fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) { + a; + *a; + &a; + &mut a; + b; + *b; + &b; + c; + *c; + d; + *d; +} + "#, + expect![[r#" + 8..9 'a': &u32 + 17..18 'b': &mut u32 + 30..31 'c': *const u32 + 45..46 'd': *mut u32 + 58..149 '{ ... *d; }': () + 64..65 'a': &u32 + 71..73 '*a': u32 + 72..73 'a': &u32 + 79..81 '&a': &&u32 + 80..81 'a': &u32 + 87..93 '&mut a': &mut &u32 + 92..93 'a': &u32 + 99..100 'b': &mut u32 + 106..108 '*b': u32 + 107..108 'b': &mut u32 + 114..116 '&b': &&mut u32 + 115..116 'b': &mut u32 + 122..123 'c': *const u32 + 129..131 '*c': u32 + 130..131 'c': *const u32 + 137..138 'd': *mut u32 + 144..146 '*d': u32 + 145..146 'd': *mut u32 + "#]], + ); +} + +#[test] +fn infer_raw_ref() { + check_infer( + r#" +fn test(a: i32) { + &raw mut a; + &raw const a; +} +"#, + expect![[r#" + 8..9 'a': i32 + 16..53 '{ ...t a; }': () + 22..32 '&raw mut a': *mut i32 + 31..32 'a': i32 + 38..50 '&raw const a': *const i32 + 49..50 'a': i32 + "#]], + ); +} + +#[test] +fn infer_literals() { + check_infer( + r##" + fn test() { + 5i32; + 5f32; + 5f64; + "hello"; + b"bytes"; + 'c'; + b'b'; + 3.14; + 5000; + false; + true; + r#" + //! doc + // non-doc + mod foo {} + "#; + br#"yolo"#; + let a = b"a\x20b\ + c"; + let b = br"g\ +h"; + let c = br#"x"\"yb"#; + } + "##, + expect![[r##" + 18..478 '{ ... }': () + 32..36 '5i32': i32 + 50..54 '5f32': f32 + 68..72 '5f64': f64 + 86..93 '"hello"': &str + 107..115 'b"bytes"': &[u8; 5] + 129..132 ''c'': char + 146..150 'b'b'': u8 + 164..168 '3.14': f64 + 182..186 '5000': i32 + 200..205 'false': bool + 219..223 'true': bool + 237..333 'r#" ... "#': &str + 347..357 'br#"yolo"#': &[u8; 4] + 375..376 'a': &[u8; 4] + 379..403 'b"a\x2... c"': &[u8; 4] + 421..422 'b': &[u8; 4] + 425..433 'br"g\ h"': &[u8; 4] + 451..452 'c': &[u8; 6] + 455..467 'br#"x"\"yb"#': &[u8; 6] + "##]], + ); +} + +#[test] +fn infer_unary_op() { + check_infer( + r#" +enum SomeType {} + +fn test(x: SomeType) { + let b = false; + let c = !b; + let a = 100; + let d: i128 = -a; + let e = -100; + let f = !!!true; + let g = !42; + let h = !10u32; + let j = !a; + -3.14; + !3; + -x; + !x; + -"hello"; + !"hello"; +} +"#, + expect![[r#" + 26..27 'x': SomeType + 39..271 '{ ...lo"; }': () + 49..50 'b': bool + 53..58 'false': bool + 68..69 'c': bool + 72..74 '!b': bool + 73..74 'b': bool + 84..85 'a': i128 + 88..91 '100': i128 + 101..102 'd': i128 + 111..113 '-a': i128 + 112..113 'a': i128 + 123..124 'e': i32 + 127..131 '-100': i32 + 128..131 '100': i32 + 141..142 'f': bool + 145..152 '!!!true': bool + 146..152 '!!true': bool + 147..152 '!true': bool + 148..152 'true': bool + 162..163 'g': i32 + 166..169 '!42': i32 + 167..169 '42': i32 + 179..180 'h': u32 + 183..189 '!10u32': u32 + 184..189 '10u32': u32 + 199..200 'j': i128 + 203..205 '!a': i128 + 204..205 'a': i128 + 211..216 '-3.14': f64 + 212..216 '3.14': f64 + 222..224 '!3': i32 + 223..224 '3': i32 + 230..232 '-x': {unknown} + 231..232 'x': SomeType + 238..240 '!x': {unknown} + 239..240 'x': SomeType + 246..254 '-"hello"': {unknown} + 247..254 '"hello"': &str + 260..268 '!"hello"': {unknown} + 261..268 '"hello"': &str + "#]], + ); +} + +#[test] +fn infer_backwards() { + check_infer( + r#" +fn takes_u32(x: u32) {} + +struct S { i32_field: i32 } + +fn test() -> &mut &f64 { + let a = unknown_function(); + takes_u32(a); + let b = unknown_function(); + S { i32_field: b }; + let c = unknown_function(); + &mut &c +} +"#, + expect![[r#" + 13..14 'x': u32 + 21..23 '{}': () + 77..230 '{ ...t &c }': &mut &f64 + 87..88 'a': u32 + 91..107 'unknow...nction': {unknown} + 91..109 'unknow...tion()': u32 + 115..124 'takes_u32': fn takes_u32(u32) + 115..127 'takes_u32(a)': () + 125..126 'a': u32 + 137..138 'b': i32 + 141..157 'unknow...nction': {unknown} + 141..159 'unknow...tion()': i32 + 165..183 'S { i3...d: b }': S + 180..181 'b': i32 + 193..194 'c': f64 + 197..213 'unknow...nction': {unknown} + 197..215 'unknow...tion()': f64 + 221..228 '&mut &c': &mut &f64 + 226..228 '&c': &f64 + 227..228 'c': f64 + "#]], + ); +} + +#[test] +fn infer_self() { + check_infer( + r#" +struct S; + +impl S { + fn test(&self) { + self; + } + fn test2(self: &Self) { + self; + } + fn test3() -> Self { + S {} + } + fn test4() -> Self { + Self {} + } +} +"#, + expect![[r#" + 33..37 'self': &S + 39..60 '{ ... }': () + 49..53 'self': &S + 74..78 'self': &S + 87..108 '{ ... }': () + 97..101 'self': &S + 132..152 '{ ... }': S + 142..146 'S {}': S + 176..199 '{ ... }': S + 186..193 'Self {}': S + "#]], + ); +} + +#[test] +fn infer_self_as_path() { + check_infer( + r#" +struct S1; +struct S2(isize); +enum E { + V1, + V2(u32), +} + +impl S1 { + fn test() { + Self; + } +} +impl S2 { + fn test() { + Self(1); + } +} +impl E { + fn test() { + Self::V1; + Self::V2(1); + } +} +"#, + expect![[r#" + 86..107 '{ ... }': () + 96..100 'Self': S1 + 134..158 '{ ... }': () + 144..148 'Self': S2(isize) -> S2 + 144..151 'Self(1)': S2 + 149..150 '1': isize + 184..230 '{ ... }': () + 194..202 'Self::V1': E + 212..220 'Self::V2': V2(u32) -> E + 212..223 'Self::V2(1)': E + 221..222 '1': u32 + "#]], + ); +} + +#[test] +fn infer_binary_op() { + check_infer( + r#" +fn f(x: bool) -> i32 { + 0i32 +} + +fn test() -> bool { + let x = a && b; + let y = true || false; + let z = x == y; + let t = x != y; + let minus_forty: isize = -40isize; + let h = minus_forty <= CONST_2; + let c = f(z || y) + 5; + let d = b; + let g = minus_forty ^= i; + let ten: usize = 10; + let ten_is_eleven = ten == some_num; + + ten < 3 +} +"#, + expect![[r#" + 5..6 'x': bool + 21..33 '{ 0i32 }': i32 + 27..31 '0i32': i32 + 53..369 '{ ... < 3 }': bool + 63..64 'x': bool + 67..68 'a': bool + 67..73 'a && b': bool + 72..73 'b': bool + 83..84 'y': bool + 87..91 'true': bool + 87..100 'true || false': bool + 95..100 'false': bool + 110..111 'z': bool + 114..115 'x': bool + 114..120 'x == y': bool + 119..120 'y': bool + 130..131 't': bool + 134..135 'x': bool + 134..140 'x != y': bool + 139..140 'y': bool + 150..161 'minus_forty': isize + 171..179 '-40isize': isize + 172..179 '40isize': isize + 189..190 'h': bool + 193..204 'minus_forty': isize + 193..215 'minus_...ONST_2': bool + 208..215 'CONST_2': isize + 225..226 'c': i32 + 229..230 'f': fn f(bool) -> i32 + 229..238 'f(z || y)': i32 + 229..242 'f(z || y) + 5': i32 + 231..232 'z': bool + 231..237 'z || y': bool + 236..237 'y': bool + 241..242 '5': i32 + 252..253 'd': {unknown} + 256..257 'b': {unknown} + 267..268 'g': () + 271..282 'minus_forty': isize + 271..287 'minus_...y ^= i': () + 286..287 'i': isize + 297..300 'ten': usize + 310..312 '10': usize + 322..335 'ten_is_eleven': bool + 338..341 'ten': usize + 338..353 'ten == some_num': bool + 345..353 'some_num': usize + 360..363 'ten': usize + 360..367 'ten < 3': bool + 366..367 '3': usize + "#]], + ); +} + +#[test] +fn infer_shift_op() { + check_infer( + r#" +fn test() { + 1u32 << 5u8; + 1u32 >> 5u8; +} +"#, + expect![[r#" + 10..47 '{ ...5u8; }': () + 16..20 '1u32': u32 + 16..27 '1u32 << 5u8': u32 + 24..27 '5u8': u8 + 33..37 '1u32': u32 + 33..44 '1u32 >> 5u8': u32 + 41..44 '5u8': u8 + "#]], + ); +} + +#[test] +fn infer_field_autoderef() { + check_infer( + r#" +struct A { + b: B, +} +struct B; + +fn test1(a: A) { + let a1 = a; + a1.b; + let a2 = &a; + a2.b; + let a3 = &mut a; + a3.b; + let a4 = &&&&&&&a; + a4.b; + let a5 = &mut &&mut &&mut a; + a5.b; +} + +fn test2(a1: *const A, a2: *mut A) { + a1.b; + a2.b; +} +"#, + expect![[r#" + 43..44 'a': A + 49..212 '{ ...5.b; }': () + 59..61 'a1': A + 64..65 'a': A + 71..73 'a1': A + 71..75 'a1.b': B + 85..87 'a2': &A + 90..92 '&a': &A + 91..92 'a': A + 98..100 'a2': &A + 98..102 'a2.b': B + 112..114 'a3': &mut A + 117..123 '&mut a': &mut A + 122..123 'a': A + 129..131 'a3': &mut A + 129..133 'a3.b': B + 143..145 'a4': &&&&&&&A + 148..156 '&&&&&&&a': &&&&&&&A + 149..156 '&&&&&&a': &&&&&&A + 150..156 '&&&&&a': &&&&&A + 151..156 '&&&&a': &&&&A + 152..156 '&&&a': &&&A + 153..156 '&&a': &&A + 154..156 '&a': &A + 155..156 'a': A + 162..164 'a4': &&&&&&&A + 162..166 'a4.b': B + 176..178 'a5': &mut &&mut &&mut A + 181..199 '&mut &...&mut a': &mut &&mut &&mut A + 186..199 '&&mut &&mut a': &&mut &&mut A + 187..199 '&mut &&mut a': &mut &&mut A + 192..199 '&&mut a': &&mut A + 193..199 '&mut a': &mut A + 198..199 'a': A + 205..207 'a5': &mut &&mut &&mut A + 205..209 'a5.b': B + 223..225 'a1': *const A + 237..239 'a2': *mut A + 249..272 '{ ...2.b; }': () + 255..257 'a1': *const A + 255..259 'a1.b': B + 265..267 'a2': *mut A + 265..269 'a2.b': B + "#]], + ); +} + +#[test] +fn infer_argument_autoderef() { + check_infer( + r#" +//- minicore: deref +use core::ops::Deref; +struct A<T>(T); + +impl<T> A<T> { + fn foo(&self) -> &T { + &self.0 + } +} + +struct B<T>(T); + +impl<T> Deref for B<T> { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +fn test() { + let t = A::foo(&&B(B(A(42)))); +} +"#, + expect![[r#" + 66..70 'self': &A<T> + 78..101 '{ ... }': &T + 88..95 '&self.0': &T + 89..93 'self': &A<T> + 89..95 'self.0': T + 182..186 'self': &B<T> + 205..228 '{ ... }': &T + 215..222 '&self.0': &T + 216..220 'self': &B<T> + 216..222 'self.0': T + 242..280 '{ ...))); }': () + 252..253 't': &i32 + 256..262 'A::foo': fn foo<i32>(&A<i32>) -> &i32 + 256..277 'A::foo...42))))': &i32 + 263..276 '&&B(B(A(42)))': &&B<B<A<i32>>> + 264..276 '&B(B(A(42)))': &B<B<A<i32>>> + 265..266 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>> + 265..276 'B(B(A(42)))': B<B<A<i32>>> + 267..268 'B': B<A<i32>>(A<i32>) -> B<A<i32>> + 267..275 'B(A(42))': B<A<i32>> + 269..270 'A': A<i32>(i32) -> A<i32> + 269..274 'A(42)': A<i32> + 271..273 '42': i32 + "#]], + ); +} + +#[test] +fn infer_method_argument_autoderef() { + check_infer( + r#" +//- minicore: deref +use core::ops::Deref; +struct A<T>(*mut T); + +impl<T> A<T> { + fn foo(&self, x: &A<T>) -> &T { + &*x.0 + } +} + +struct B<T>(T); + +impl<T> Deref for B<T> { + type Target = T; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +fn test(a: A<i32>) { + let t = A(0 as *mut _).foo(&&B(B(a))); +} +"#, + expect![[r#" + 71..75 'self': &A<T> + 77..78 'x': &A<T> + 93..114 '{ ... }': &T + 103..108 '&*x.0': &T + 104..108 '*x.0': T + 105..106 'x': &A<T> + 105..108 'x.0': *mut T + 195..199 'self': &B<T> + 218..241 '{ ... }': &T + 228..235 '&self.0': &T + 229..233 'self': &B<T> + 229..235 'self.0': T + 253..254 'a': A<i32> + 264..310 '{ ...))); }': () + 274..275 't': &i32 + 278..279 'A': A<i32>(*mut i32) -> A<i32> + 278..292 'A(0 as *mut _)': A<i32> + 278..307 'A(0 as...B(a)))': &i32 + 280..281 '0': i32 + 280..291 '0 as *mut _': *mut i32 + 297..306 '&&B(B(a))': &&B<B<A<i32>>> + 298..306 '&B(B(a))': &B<B<A<i32>>> + 299..300 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>> + 299..306 'B(B(a))': B<B<A<i32>>> + 301..302 'B': B<A<i32>>(A<i32>) -> B<A<i32>> + 301..305 'B(a)': B<A<i32>> + 303..304 'a': A<i32> + "#]], + ); +} + +#[test] +fn infer_in_elseif() { + check_infer( + r#" +struct Foo { field: i32 } +fn main(foo: Foo) { + if true { + + } else if false { + foo.field + } +} +"#, + expect![[r#" + 34..37 'foo': Foo + 44..108 '{ ... } }': () + 50..106 'if tru... }': () + 53..57 'true': bool + 58..66 '{ }': () + 72..106 'if fal... }': () + 75..80 'false': bool + 81..106 '{ ... }': () + 91..94 'foo': Foo + 91..100 'foo.field': i32 + "#]], + ) +} + +#[test] +fn infer_if_match_with_return() { + check_infer( + r#" +fn foo() { + let _x1 = if true { + 1 + } else { + return; + }; + let _x2 = if true { + 2 + } else { + return + }; + let _x3 = match true { + true => 3, + _ => { + return; + } + }; + let _x4 = match true { + true => 4, + _ => return + }; +} +"#, + expect![[r#" + 9..322 '{ ... }; }': () + 19..22 '_x1': i32 + 25..79 'if tru... }': i32 + 28..32 'true': bool + 33..50 '{ ... }': i32 + 43..44 '1': i32 + 56..79 '{ ... }': i32 + 66..72 'return': ! + 89..92 '_x2': i32 + 95..148 'if tru... }': i32 + 98..102 'true': bool + 103..120 '{ ... }': i32 + 113..114 '2': i32 + 126..148 '{ ... }': ! + 136..142 'return': ! + 158..161 '_x3': i32 + 164..246 'match ... }': i32 + 170..174 'true': bool + 185..189 'true': bool + 185..189 'true': bool + 193..194 '3': i32 + 204..205 '_': bool + 209..240 '{ ... }': i32 + 223..229 'return': ! + 256..259 '_x4': i32 + 262..319 'match ... }': i32 + 268..272 'true': bool + 283..287 'true': bool + 283..287 'true': bool + 291..292 '4': i32 + 302..303 '_': bool + 307..313 'return': ! + "#]], + ) +} + +#[test] +fn infer_inherent_method() { + check_infer( + r#" + struct A; + + impl A { + fn foo(self, x: u32) -> i32 {} + } + + mod b { + impl super::A { + pub fn bar(&self, x: u64) -> i64 {} + } + } + + fn test(a: A) { + a.foo(1); + (&a).bar(1); + a.bar(1); + } + "#, + expect![[r#" + 31..35 'self': A + 37..38 'x': u32 + 52..54 '{}': i32 + 106..110 'self': &A + 112..113 'x': u64 + 127..129 '{}': i64 + 147..148 'a': A + 153..201 '{ ...(1); }': () + 159..160 'a': A + 159..167 'a.foo(1)': i32 + 165..166 '1': u32 + 173..184 '(&a).bar(1)': i64 + 174..176 '&a': &A + 175..176 'a': A + 182..183 '1': u64 + 190..191 'a': A + 190..198 'a.bar(1)': i64 + 196..197 '1': u64 + "#]], + ); +} + +#[test] +fn infer_inherent_method_str() { + check_infer( + r#" + #[lang = "str"] + impl str { + fn foo(&self) -> i32 {} + } + + fn test() { + "foo".foo(); + } + "#, + expect![[r#" + 39..43 'self': &str + 52..54 '{}': i32 + 68..88 '{ ...o(); }': () + 74..79 '"foo"': &str + 74..85 '"foo".foo()': i32 + "#]], + ); +} + +#[test] +fn infer_tuple() { + check_infer( + r#" + fn test(x: &str, y: isize) { + let a: (u32, &str) = (1, "a"); + let b = (a, x); + let c = (y, x); + let d = (c, x); + let e = (1, "e"); + let f = (e, "d"); + } + "#, + expect![[r#" + 8..9 'x': &str + 17..18 'y': isize + 27..169 '{ ...d"); }': () + 37..38 'a': (u32, &str) + 54..62 '(1, "a")': (u32, &str) + 55..56 '1': u32 + 58..61 '"a"': &str + 72..73 'b': ((u32, &str), &str) + 76..82 '(a, x)': ((u32, &str), &str) + 77..78 'a': (u32, &str) + 80..81 'x': &str + 92..93 'c': (isize, &str) + 96..102 '(y, x)': (isize, &str) + 97..98 'y': isize + 100..101 'x': &str + 112..113 'd': ((isize, &str), &str) + 116..122 '(c, x)': ((isize, &str), &str) + 117..118 'c': (isize, &str) + 120..121 'x': &str + 132..133 'e': (i32, &str) + 136..144 '(1, "e")': (i32, &str) + 137..138 '1': i32 + 140..143 '"e"': &str + 154..155 'f': ((i32, &str), &str) + 158..166 '(e, "d")': ((i32, &str), &str) + 159..160 'e': (i32, &str) + 162..165 '"d"': &str + "#]], + ); +} + +#[test] +fn infer_array() { + check_infer( + r#" + fn test(x: &str, y: isize) { + let a = [x]; + let b = [a, a]; + let c = [b, b]; + + let d = [y, 1, 2, 3]; + let d = [1, y, 2, 3]; + let e = [y]; + let f = [d, d]; + let g = [e, e]; + + let h = [1, 2]; + let i = ["a", "b"]; + + let b = [a, ["b"]]; + let x: [u8; 0] = []; + let y: [u8; 2+2] = [1,2,3,4]; + } + "#, + expect![[r#" + 8..9 'x': &str + 17..18 'y': isize + 27..326 '{ ...,4]; }': () + 37..38 'a': [&str; 1] + 41..44 '[x]': [&str; 1] + 42..43 'x': &str + 54..55 'b': [[&str; 1]; 2] + 58..64 '[a, a]': [[&str; 1]; 2] + 59..60 'a': [&str; 1] + 62..63 'a': [&str; 1] + 74..75 'c': [[[&str; 1]; 2]; 2] + 78..84 '[b, b]': [[[&str; 1]; 2]; 2] + 79..80 'b': [[&str; 1]; 2] + 82..83 'b': [[&str; 1]; 2] + 95..96 'd': [isize; 4] + 99..111 '[y, 1, 2, 3]': [isize; 4] + 100..101 'y': isize + 103..104 '1': isize + 106..107 '2': isize + 109..110 '3': isize + 121..122 'd': [isize; 4] + 125..137 '[1, y, 2, 3]': [isize; 4] + 126..127 '1': isize + 129..130 'y': isize + 132..133 '2': isize + 135..136 '3': isize + 147..148 'e': [isize; 1] + 151..154 '[y]': [isize; 1] + 152..153 'y': isize + 164..165 'f': [[isize; 4]; 2] + 168..174 '[d, d]': [[isize; 4]; 2] + 169..170 'd': [isize; 4] + 172..173 'd': [isize; 4] + 184..185 'g': [[isize; 1]; 2] + 188..194 '[e, e]': [[isize; 1]; 2] + 189..190 'e': [isize; 1] + 192..193 'e': [isize; 1] + 205..206 'h': [i32; 2] + 209..215 '[1, 2]': [i32; 2] + 210..211 '1': i32 + 213..214 '2': i32 + 225..226 'i': [&str; 2] + 229..239 '["a", "b"]': [&str; 2] + 230..233 '"a"': &str + 235..238 '"b"': &str + 250..251 'b': [[&str; 1]; 2] + 254..264 '[a, ["b"]]': [[&str; 1]; 2] + 255..256 'a': [&str; 1] + 258..263 '["b"]': [&str; 1] + 259..262 '"b"': &str + 274..275 'x': [u8; 0] + 287..289 '[]': [u8; 0] + 299..300 'y': [u8; 4] + 314..323 '[1,2,3,4]': [u8; 4] + 315..316 '1': u8 + 317..318 '2': u8 + 319..320 '3': u8 + 321..322 '4': u8 + "#]], + ); +} + +#[test] +fn infer_struct_generics() { + check_infer( + r#" + struct A<T> { + x: T, + } + + fn test(a1: A<u32>, i: i32) { + a1.x; + let a2 = A { x: i }; + a2.x; + let a3 = A::<i128> { x: 1 }; + a3.x; + } + "#, + expect![[r#" + 35..37 'a1': A<u32> + 47..48 'i': i32 + 55..146 '{ ...3.x; }': () + 61..63 'a1': A<u32> + 61..65 'a1.x': u32 + 75..77 'a2': A<i32> + 80..90 'A { x: i }': A<i32> + 87..88 'i': i32 + 96..98 'a2': A<i32> + 96..100 'a2.x': i32 + 110..112 'a3': A<i128> + 115..133 'A::<i1...x: 1 }': A<i128> + 130..131 '1': i128 + 139..141 'a3': A<i128> + 139..143 'a3.x': i128 + "#]], + ); +} + +#[test] +fn infer_tuple_struct_generics() { + check_infer( + r#" + struct A<T>(T); + enum Option<T> { Some(T), None } + use Option::*; + + fn test() { + A(42); + A(42u128); + Some("x"); + Option::Some("x"); + None; + let x: Option<i64> = None; + } + "#, + expect![[r#" + 75..183 '{ ...one; }': () + 81..82 'A': A<i32>(i32) -> A<i32> + 81..86 'A(42)': A<i32> + 83..85 '42': i32 + 92..93 'A': A<u128>(u128) -> A<u128> + 92..101 'A(42u128)': A<u128> + 94..100 '42u128': u128 + 107..111 'Some': Some<&str>(&str) -> Option<&str> + 107..116 'Some("x")': Option<&str> + 112..115 '"x"': &str + 122..134 'Option::Some': Some<&str>(&str) -> Option<&str> + 122..139 'Option...e("x")': Option<&str> + 135..138 '"x"': &str + 145..149 'None': Option<{unknown}> + 159..160 'x': Option<i64> + 176..180 'None': Option<i64> + "#]], + ); +} + +#[test] +fn infer_function_generics() { + check_infer( + r#" + fn id<T>(t: T) -> T { t } + + fn test() { + id(1u32); + id::<i128>(1); + let x: u64 = id(1); + } + "#, + expect![[r#" + 9..10 't': T + 20..25 '{ t }': T + 22..23 't': T + 37..97 '{ ...(1); }': () + 43..45 'id': fn id<u32>(u32) -> u32 + 43..51 'id(1u32)': u32 + 46..50 '1u32': u32 + 57..67 'id::<i128>': fn id<i128>(i128) -> i128 + 57..70 'id::<i128>(1)': i128 + 68..69 '1': i128 + 80..81 'x': u64 + 89..91 'id': fn id<u64>(u64) -> u64 + 89..94 'id(1)': u64 + 92..93 '1': u64 + "#]], + ); +} + +#[test] +fn infer_impl_generics_basic() { + check_infer( + r#" + struct A<T1, T2> { + x: T1, + y: T2, + } + impl<Y, X> A<X, Y> { + fn x(self) -> X { + self.x + } + fn y(self) -> Y { + self.y + } + fn z<T>(self, t: T) -> (X, Y, T) { + (self.x, self.y, t) + } + } + + fn test() -> i128 { + let a = A { x: 1u64, y: 1i64 }; + a.x(); + a.y(); + a.z(1i128); + a.z::<u128>(1); + } + "#, + expect![[r#" + 73..77 'self': A<X, Y> + 84..106 '{ ... }': X + 94..98 'self': A<X, Y> + 94..100 'self.x': X + 116..120 'self': A<X, Y> + 127..149 '{ ... }': Y + 137..141 'self': A<X, Y> + 137..143 'self.y': Y + 162..166 'self': A<X, Y> + 168..169 't': T + 187..222 '{ ... }': (X, Y, T) + 197..216 '(self.....y, t)': (X, Y, T) + 198..202 'self': A<X, Y> + 198..204 'self.x': X + 206..210 'self': A<X, Y> + 206..212 'self.y': Y + 214..215 't': T + 244..341 '{ ...(1); }': i128 + 254..255 'a': A<u64, i64> + 258..280 'A { x:...1i64 }': A<u64, i64> + 265..269 '1u64': u64 + 274..278 '1i64': i64 + 286..287 'a': A<u64, i64> + 286..291 'a.x()': u64 + 297..298 'a': A<u64, i64> + 297..302 'a.y()': i64 + 308..309 'a': A<u64, i64> + 308..318 'a.z(1i128)': (u64, i64, i128) + 312..317 '1i128': i128 + 324..325 'a': A<u64, i64> + 324..338 'a.z::<u128>(1)': (u64, i64, u128) + 336..337 '1': u128 + "#]], + ); +} + +#[test] +fn infer_impl_generics_with_autoderef() { + check_infer( + r#" + enum Option<T> { + Some(T), + None, + } + impl<T> Option<T> { + fn as_ref(&self) -> Option<&T> {} + } + fn test(o: Option<u32>) { + (&o).as_ref(); + o.as_ref(); + } + "#, + expect![[r#" + 77..81 'self': &Option<T> + 97..99 '{}': Option<&T> + 110..111 'o': Option<u32> + 126..164 '{ ...f(); }': () + 132..145 '(&o).as_ref()': Option<&u32> + 133..135 '&o': &Option<u32> + 134..135 'o': Option<u32> + 151..152 'o': Option<u32> + 151..161 'o.as_ref()': Option<&u32> + "#]], + ); +} + +#[test] +fn infer_generic_chain() { + check_infer( + r#" + struct A<T> { + x: T, + } + impl<T2> A<T2> { + fn x(self) -> T2 { + self.x + } + } + fn id<T>(t: T) -> T { t } + + fn test() -> i128 { + let x = 1; + let y = id(x); + let a = A { x: id(y) }; + let z = id(a.x); + let b = A { x: z }; + b.x() + } + "#, + expect![[r#" + 52..56 'self': A<T2> + 64..86 '{ ... }': T2 + 74..78 'self': A<T2> + 74..80 'self.x': T2 + 98..99 't': T + 109..114 '{ t }': T + 111..112 't': T + 134..254 '{ ....x() }': i128 + 144..145 'x': i128 + 148..149 '1': i128 + 159..160 'y': i128 + 163..165 'id': fn id<i128>(i128) -> i128 + 163..168 'id(x)': i128 + 166..167 'x': i128 + 178..179 'a': A<i128> + 182..196 'A { x: id(y) }': A<i128> + 189..191 'id': fn id<i128>(i128) -> i128 + 189..194 'id(y)': i128 + 192..193 'y': i128 + 206..207 'z': i128 + 210..212 'id': fn id<i128>(i128) -> i128 + 210..217 'id(a.x)': i128 + 213..214 'a': A<i128> + 213..216 'a.x': i128 + 227..228 'b': A<i128> + 231..241 'A { x: z }': A<i128> + 238..239 'z': i128 + 247..248 'b': A<i128> + 247..252 'b.x()': i128 + "#]], + ); +} + +#[test] +fn infer_associated_const() { + check_infer( + r#" + struct Struct; + + impl Struct { + const FOO: u32 = 1; + } + + enum Enum {} + + impl Enum { + const BAR: u32 = 2; + } + + trait Trait { + const ID: u32; + } + + struct TraitTest; + + impl Trait for TraitTest { + const ID: u32 = 5; + } + + fn test() { + let x = Struct::FOO; + let y = Enum::BAR; + let z = TraitTest::ID; + } + "#, + expect![[r#" + 51..52 '1': u32 + 104..105 '2': u32 + 212..213 '5': u32 + 228..306 '{ ...:ID; }': () + 238..239 'x': u32 + 242..253 'Struct::FOO': u32 + 263..264 'y': u32 + 267..276 'Enum::BAR': u32 + 286..287 'z': u32 + 290..303 'TraitTest::ID': u32 + "#]], + ); +} + +#[test] +fn infer_type_alias() { + check_infer( + r#" + struct A<X, Y> { x: X, y: Y } + type Foo = A<u32, i128>; + type Bar<T> = A<T, u128>; + type Baz<U, V> = A<V, U>; + fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) { + x.x; + x.y; + y.x; + y.y; + z.x; + z.y; + } + mod m { + pub enum Enum { + Foo(u8), + } + pub type Alias = Enum; + } + fn f() { + let e = m::Alias::Foo(0); + let m::Alias::Foo(x) = &e; + } + "#, + expect![[r#" + 115..116 'x': A<u32, i128> + 123..124 'y': A<&str, u128> + 137..138 'z': A<u8, i8> + 153..210 '{ ...z.y; }': () + 159..160 'x': A<u32, i128> + 159..162 'x.x': u32 + 168..169 'x': A<u32, i128> + 168..171 'x.y': i128 + 177..178 'y': A<&str, u128> + 177..180 'y.x': &str + 186..187 'y': A<&str, u128> + 186..189 'y.y': u128 + 195..196 'z': A<u8, i8> + 195..198 'z.x': u8 + 204..205 'z': A<u8, i8> + 204..207 'z.y': i8 + 298..362 '{ ... &e; }': () + 308..309 'e': Enum + 312..325 'm::Alias::Foo': Foo(u8) -> Enum + 312..328 'm::Ali...Foo(0)': Enum + 326..327 '0': u8 + 338..354 'm::Ali...Foo(x)': Enum + 352..353 'x': &u8 + 357..359 '&e': &Enum + 358..359 'e': Enum + "#]], + ) +} + +#[test] +fn recursive_type_alias() { + check_infer( + r#" + struct A<X> {} + type Foo = Foo; + type Bar = A<Bar>; + fn test(x: Foo) {} + "#, + expect![[r#" + 58..59 'x': {unknown} + 66..68 '{}': () + "#]], + ) +} + +#[test] +fn infer_type_param() { + check_infer( + r#" + fn id<T>(x: T) -> T { + x + } + + fn clone<T>(x: &T) -> T { + *x + } + + fn test() { + let y = 10u32; + id(y); + let x: bool = clone(z); + id::<i128>(1); + } + "#, + expect![[r#" + 9..10 'x': T + 20..29 '{ x }': T + 26..27 'x': T + 43..44 'x': &T + 55..65 '{ *x }': T + 61..63 '*x': T + 62..63 'x': &T + 77..157 '{ ...(1); }': () + 87..88 'y': u32 + 91..96 '10u32': u32 + 102..104 'id': fn id<u32>(u32) -> u32 + 102..107 'id(y)': u32 + 105..106 'y': u32 + 117..118 'x': bool + 127..132 'clone': fn clone<bool>(&bool) -> bool + 127..135 'clone(z)': bool + 133..134 'z': &bool + 141..151 'id::<i128>': fn id<i128>(i128) -> i128 + 141..154 'id::<i128>(1)': i128 + 152..153 '1': i128 + "#]], + ); +} + +#[test] +fn infer_const() { + check_infer( + r#" + struct Foo; + impl Foo { const ASSOC_CONST: u32 = 0; } + const GLOBAL_CONST: u32 = 101; + fn test() { + const LOCAL_CONST: u32 = 99; + let x = LOCAL_CONST; + let z = GLOBAL_CONST; + let id = Foo::ASSOC_CONST; + } + "#, + expect![[r#" + 48..49 '0': u32 + 79..82 '101': u32 + 94..212 '{ ...NST; }': () + 137..138 'x': u32 + 141..152 'LOCAL_CONST': u32 + 162..163 'z': u32 + 166..178 'GLOBAL_CONST': u32 + 188..190 'id': u32 + 193..209 'Foo::A..._CONST': u32 + 125..127 '99': u32 + "#]], + ); +} + +#[test] +fn infer_static() { + check_infer( + r#" + static GLOBAL_STATIC: u32 = 101; + static mut GLOBAL_STATIC_MUT: u32 = 101; + fn test() { + static LOCAL_STATIC: u32 = 99; + static mut LOCAL_STATIC_MUT: u32 = 99; + let x = LOCAL_STATIC; + let y = LOCAL_STATIC_MUT; + let z = GLOBAL_STATIC; + let w = GLOBAL_STATIC_MUT; + } + "#, + expect![[r#" + 28..31 '101': u32 + 69..72 '101': u32 + 84..279 '{ ...MUT; }': () + 172..173 'x': u32 + 176..188 'LOCAL_STATIC': u32 + 198..199 'y': u32 + 202..218 'LOCAL_...IC_MUT': u32 + 228..229 'z': u32 + 232..245 'GLOBAL_STATIC': u32 + 255..256 'w': u32 + 259..276 'GLOBAL...IC_MUT': u32 + 117..119 '99': u32 + 160..162 '99': u32 + "#]], + ); +} + +#[test] +fn shadowing_primitive() { + check_types( + r#" +struct i32; +struct Foo; + +impl i32 { fn foo(&self) -> Foo { Foo } } + +fn main() { + let x: i32 = i32; + x.foo(); + //^^^^^^^ Foo +}"#, + ); +} + +#[test] +fn const_eval_array_repeat_expr() { + check_types( + r#" +fn main() { + const X: usize = 6 - 1; + let t = [(); X + 2]; + //^ [(); 7] +}"#, + ); +} + +#[test] +fn shadowing_primitive_with_inner_items() { + check_types( + r#" +struct i32; +struct Foo; + +impl i32 { fn foo(&self) -> Foo { Foo } } + +fn main() { + fn inner() {} + let x: i32 = i32; + x.foo(); + //^^^^^^^ Foo +}"#, + ); +} + +#[test] +fn not_shadowing_primitive_by_module() { + check_types( + r#" +//- /str.rs +fn foo() {} + +//- /main.rs +mod str; +fn foo() -> &'static str { "" } + +fn main() { + foo(); + //^^^^^ &str +}"#, + ); +} + +#[test] +fn not_shadowing_module_by_primitive() { + check_types( + r#" +//- /str.rs +fn foo() -> u32 {0} + +//- /main.rs +mod str; +fn foo() -> &'static str { "" } + +fn main() { + str::foo(); + //^^^^^^^^^^ u32 +}"#, + ); +} + +// This test is actually testing the shadowing behavior within hir_def. It +// lives here because the testing infrastructure in hir_def isn't currently +// capable of asserting the necessary conditions. +#[test] +fn should_be_shadowing_imports() { + check_types( + r#" +mod a { + pub fn foo() -> i8 {0} + pub struct foo { a: i8 } +} +mod b { pub fn foo () -> u8 {0} } +mod c { pub struct foo { a: u8 } } +mod d { + pub use super::a::*; + pub use super::c::foo; + pub use super::b::foo; +} + +fn main() { + d::foo(); + //^^^^^^^^ u8 + d::foo{a:0}; + //^^^^^^^^^^^ foo +}"#, + ); +} + +#[test] +fn closure_return() { + check_infer( + r#" + fn foo() -> u32 { + let x = || -> usize { return 1; }; + } + "#, + expect![[r#" + 16..58 '{ ...; }; }': u32 + 26..27 'x': || -> usize + 30..55 '|| -> ...n 1; }': || -> usize + 42..55 '{ return 1; }': usize + 44..52 'return 1': ! + 51..52 '1': usize + "#]], + ); +} + +#[test] +fn closure_return_unit() { + check_infer( + r#" + fn foo() -> u32 { + let x = || { return; }; + } + "#, + expect![[r#" + 16..47 '{ ...; }; }': u32 + 26..27 'x': || -> () + 30..44 '|| { return; }': || -> () + 33..44 '{ return; }': () + 35..41 'return': ! + "#]], + ); +} + +#[test] +fn closure_return_inferred() { + check_infer( + r#" + fn foo() -> u32 { + let x = || { "test" }; + } + "#, + expect![[r#" + 16..46 '{ ..." }; }': u32 + 26..27 'x': || -> &str + 30..43 '|| { "test" }': || -> &str + 33..43 '{ "test" }': &str + 35..41 '"test"': &str + "#]], + ); +} + +#[test] +fn fn_pointer_return() { + check_infer( + r#" + struct Vtable { + method: fn(), + } + + fn main() { + let vtable = Vtable { method: || {} }; + let m = vtable.method; + } + "#, + expect![[r#" + 47..120 '{ ...hod; }': () + 57..63 'vtable': Vtable + 66..90 'Vtable...| {} }': Vtable + 83..88 '|| {}': || -> () + 86..88 '{}': () + 100..101 'm': fn() + 104..110 'vtable': Vtable + 104..117 'vtable.method': fn() + "#]], + ); +} + +#[test] +fn block_modifiers_smoke_test() { + check_infer( + r#" +//- minicore: future +async fn main() { + let x = unsafe { 92 }; + let y = async { async { () }.await }; + let z = try { () }; + let w = const { 92 }; + let t = 'a: { 92 }; +} + "#, + expect![[r#" + 16..162 '{ ...2 }; }': () + 26..27 'x': i32 + 30..43 'unsafe { 92 }': i32 + 30..43 'unsafe { 92 }': i32 + 39..41 '92': i32 + 53..54 'y': impl Future<Output = ()> + 57..85 'async ...wait }': () + 57..85 'async ...wait }': impl Future<Output = ()> + 65..77 'async { () }': () + 65..77 'async { () }': impl Future<Output = ()> + 65..83 'async ....await': () + 73..75 '()': () + 95..96 'z': {unknown} + 99..109 'try { () }': () + 99..109 'try { () }': {unknown} + 105..107 '()': () + 119..120 'w': i32 + 123..135 'const { 92 }': i32 + 123..135 'const { 92 }': i32 + 131..133 '92': i32 + 145..146 't': i32 + 149..159 ''a: { 92 }': i32 + 155..157 '92': i32 + "#]], + ) +} +#[test] +fn async_block_early_return() { + check_infer( + r#" +//- minicore: future, result, fn +fn test<I, E, F: FnMut() -> Fut, Fut: core::future::Future<Output = Result<I, E>>>(f: F) {} + +fn main() { + async { + return Err(()); + Ok(()) + }; + test(|| async { + return Err(()); + Ok(()) + }); +} + "#, + expect![[r#" + 83..84 'f': F + 89..91 '{}': () + 103..231 '{ ... }); }': () + 109..161 'async ... }': Result<(), ()> + 109..161 'async ... }': impl Future<Output = Result<(), ()>> + 125..139 'return Err(())': ! + 132..135 'Err': Err<(), ()>(()) -> Result<(), ()> + 132..139 'Err(())': Result<(), ()> + 136..138 '()': () + 149..151 'Ok': Ok<(), ()>(()) -> Result<(), ()> + 149..155 'Ok(())': Result<(), ()> + 152..154 '()': () + 167..171 'test': fn test<(), (), || -> impl Future<Output = Result<(), ()>>, impl Future<Output = Result<(), ()>>>(|| -> impl Future<Output = Result<(), ()>>) + 167..228 'test(|... })': () + 172..227 '|| asy... }': || -> impl Future<Output = Result<(), ()>> + 175..227 'async ... }': Result<(), ()> + 175..227 'async ... }': impl Future<Output = Result<(), ()>> + 191..205 'return Err(())': ! + 198..201 'Err': Err<(), ()>(()) -> Result<(), ()> + 198..205 'Err(())': Result<(), ()> + 202..204 '()': () + 215..217 'Ok': Ok<(), ()>(()) -> Result<(), ()> + 215..221 'Ok(())': Result<(), ()> + 218..220 '()': () + "#]], + ) +} + +#[test] +fn infer_generic_from_later_assignment() { + check_infer( + r#" + enum Option<T> { Some(T), None } + use Option::*; + + fn test() { + let mut end = None; + loop { + end = Some(true); + } + } + "#, + expect![[r#" + 59..129 '{ ... } }': () + 69..76 'mut end': Option<bool> + 79..83 'None': Option<bool> + 89..127 'loop {... }': ! + 94..127 '{ ... }': () + 104..107 'end': Option<bool> + 104..120 'end = ...(true)': () + 110..114 'Some': Some<bool>(bool) -> Option<bool> + 110..120 'Some(true)': Option<bool> + 115..119 'true': bool + "#]], + ); +} + +#[test] +fn infer_loop_break_with_val() { + check_infer( + r#" + enum Option<T> { Some(T), None } + use Option::*; + + fn test() { + let x = loop { + if false { + break None; + } + + break Some(true); + }; + } + "#, + expect![[r#" + 59..168 '{ ... }; }': () + 69..70 'x': Option<bool> + 73..165 'loop {... }': Option<bool> + 78..165 '{ ... }': () + 88..132 'if fal... }': () + 91..96 'false': bool + 97..132 '{ ... }': () + 111..121 'break None': ! + 117..121 'None': Option<bool> + 142..158 'break ...(true)': ! + 148..152 'Some': Some<bool>(bool) -> Option<bool> + 148..158 'Some(true)': Option<bool> + 153..157 'true': bool + "#]], + ); +} + +#[test] +fn infer_loop_break_without_val() { + check_infer( + r#" + enum Option<T> { Some(T), None } + use Option::*; + + fn test() { + let x = loop { + if false { + break; + } + }; + } + "#, + expect![[r#" + 59..136 '{ ... }; }': () + 69..70 'x': () + 73..133 'loop {... }': () + 78..133 '{ ... }': () + 88..127 'if fal... }': () + 91..96 'false': bool + 97..127 '{ ... }': () + 111..116 'break': ! + "#]], + ); +} + +#[test] +fn infer_labelled_break_with_val() { + check_infer( + r#" + fn foo() { + let _x = || 'outer: loop { + let inner = 'inner: loop { + let i = Default::default(); + if (break 'outer i) { + loop { break 'inner 5i8; }; + } else if true { + break 'inner 6; + } + break 7; + }; + break inner < 8; + }; + } + "#, + expect![[r#" + 9..335 '{ ... }; }': () + 19..21 '_x': || -> bool + 24..332 '|| 'ou... }': || -> bool + 27..332 ''outer... }': bool + 40..332 '{ ... }': () + 54..59 'inner': i8 + 62..300 ''inner... }': i8 + 75..300 '{ ... }': () + 93..94 'i': bool + 97..113 'Defaul...efault': {unknown} + 97..115 'Defaul...ault()': bool + 129..269 'if (br... }': () + 133..147 'break 'outer i': ! + 146..147 'i': bool + 149..208 '{ ... }': () + 167..193 'loop {...5i8; }': ! + 172..193 '{ brea...5i8; }': () + 174..190 'break ...er 5i8': ! + 187..190 '5i8': i8 + 214..269 'if tru... }': () + 217..221 'true': bool + 222..269 '{ ... }': () + 240..254 'break 'inner 6': ! + 253..254 '6': i8 + 282..289 'break 7': ! + 288..289 '7': i8 + 310..325 'break inner < 8': ! + 316..321 'inner': i8 + 316..325 'inner < 8': bool + 324..325 '8': i8 + "#]], + ); +} + +#[test] +fn infer_labelled_block_break_with_val() { + check_infer( + r#" +fn default<T>() -> T { loop {} } +fn foo() { + let _x = 'outer: { + let inner = 'inner: { + let i = default(); + if (break 'outer i) { + break 'inner 5i8; + } else if true { + break 'inner 6; + } + break 'inner 'innermost: { 0 }; + 42 + }; + break 'outer inner < 8; + }; +} +"#, + expect![[r#" + 21..32 '{ loop {} }': T + 23..30 'loop {}': ! + 28..30 '{}': () + 42..381 '{ ... }; }': () + 52..54 '_x': bool + 57..378 ''outer... }': bool + 79..84 'inner': i8 + 87..339 ''inner... }': i8 + 113..114 'i': bool + 117..124 'default': fn default<bool>() -> bool + 117..126 'default()': bool + 140..270 'if (br... }': () + 144..158 'break 'outer i': ! + 157..158 'i': bool + 160..209 '{ ... }': () + 178..194 'break ...er 5i8': ! + 191..194 '5i8': i8 + 215..270 'if tru... }': () + 218..222 'true': bool + 223..270 '{ ... }': () + 241..255 'break 'inner 6': ! + 254..255 '6': i8 + 283..313 'break ... { 0 }': ! + 296..313 ''inner... { 0 }': i8 + 310..311 '0': i8 + 327..329 '42': i8 + 349..371 'break ...er < 8': ! + 362..367 'inner': i8 + 362..371 'inner < 8': bool + 370..371 '8': i8 + "#]], + ); +} + +#[test] +fn generic_default() { + check_infer( + r#" + struct Thing<T = ()> { t: T } + enum OtherThing<T = ()> { + One { t: T }, + Two(T), + } + + fn test(t1: Thing, t2: OtherThing, t3: Thing<i32>, t4: OtherThing<i32>) { + t1.t; + t3.t; + match t2 { + OtherThing::One { t } => { t; }, + OtherThing::Two(t) => { t; }, + } + match t4 { + OtherThing::One { t } => { t; }, + OtherThing::Two(t) => { t; }, + } + } + "#, + expect![[r#" + 97..99 't1': Thing<()> + 108..110 't2': OtherThing<()> + 124..126 't3': Thing<i32> + 140..142 't4': OtherThing<i32> + 161..384 '{ ... } }': () + 167..169 't1': Thing<()> + 167..171 't1.t': () + 177..179 't3': Thing<i32> + 177..181 't3.t': i32 + 187..282 'match ... }': () + 193..195 't2': OtherThing<()> + 206..227 'OtherT... { t }': OtherThing<()> + 224..225 't': () + 231..237 '{ t; }': () + 233..234 't': () + 247..265 'OtherT...Two(t)': OtherThing<()> + 263..264 't': () + 269..275 '{ t; }': () + 271..272 't': () + 287..382 'match ... }': () + 293..295 't4': OtherThing<i32> + 306..327 'OtherT... { t }': OtherThing<i32> + 324..325 't': i32 + 331..337 '{ t; }': () + 333..334 't': i32 + 347..365 'OtherT...Two(t)': OtherThing<i32> + 363..364 't': i32 + 369..375 '{ t; }': () + 371..372 't': i32 + "#]], + ); +} + +#[test] +fn generic_default_in_struct_literal() { + check_infer( + r#" + struct Thing<T = ()> { t: T } + enum OtherThing<T = ()> { + One { t: T }, + Two(T), + } + + fn test() { + let x = Thing { t: loop {} }; + let y = Thing { t: () }; + let z = Thing { t: 1i32 }; + if let Thing { t } = z { + t; + } + + let a = OtherThing::One { t: 1i32 }; + let b = OtherThing::Two(1i32); + } + "#, + expect![[r#" + 99..319 '{ ...32); }': () + 109..110 'x': Thing<!> + 113..133 'Thing ...p {} }': Thing<!> + 124..131 'loop {}': ! + 129..131 '{}': () + 143..144 'y': Thing<()> + 147..162 'Thing { t: () }': Thing<()> + 158..160 '()': () + 172..173 'z': Thing<i32> + 176..193 'Thing ...1i32 }': Thing<i32> + 187..191 '1i32': i32 + 199..240 'if let... }': () + 202..221 'let Th... } = z': bool + 206..217 'Thing { t }': Thing<i32> + 214..215 't': i32 + 220..221 'z': Thing<i32> + 222..240 '{ ... }': () + 232..233 't': i32 + 250..251 'a': OtherThing<i32> + 254..281 'OtherT...1i32 }': OtherThing<i32> + 275..279 '1i32': i32 + 291..292 'b': OtherThing<i32> + 295..310 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32> + 295..316 'OtherT...(1i32)': OtherThing<i32> + 311..315 '1i32': i32 + "#]], + ); +} + +#[test] +fn generic_default_depending_on_other_type_arg() { + // FIXME: the {unknown} is a bug + check_infer( + r#" + struct Thing<T = u128, F = fn() -> T> { t: T } + + fn test(t1: Thing<u32>, t2: Thing) { + t1; + t2; + Thing::<_> { t: 1u32 }; + } + "#, + expect![[r#" + 56..58 't1': Thing<u32, fn() -> u32> + 72..74 't2': Thing<u128, fn() -> u128> + 83..130 '{ ...2 }; }': () + 89..91 't1': Thing<u32, fn() -> u32> + 97..99 't2': Thing<u128, fn() -> u128> + 105..127 'Thing:...1u32 }': Thing<u32, fn() -> {unknown}> + 121..125 '1u32': u32 + "#]], + ); +} + +#[test] +fn generic_default_depending_on_other_type_arg_forward() { + // the {unknown} here is intentional, as defaults are not allowed to + // refer to type parameters coming later + check_infer( + r#" + struct Thing<F = fn() -> T, T = u128> { t: T } + + fn test(t1: Thing) { + t1; + } + "#, + expect![[r#" + 56..58 't1': Thing<fn() -> {unknown}, u128> + 67..78 '{ t1; }': () + 73..75 't1': Thing<fn() -> {unknown}, u128> + "#]], + ); +} + +#[test] +fn infer_operator_overload() { + check_types( + r#" +//- minicore: add +struct V2([f32; 2]); + +impl core::ops::Add<V2> for V2 { + type Output = V2; +} + +fn test() { + let va = V2([0.0, 1.0]); + let vb = V2([0.0, 1.0]); + + let r = va + vb; + // ^^^^^^^ V2 +} + + "#, + ); +} + +#[test] +fn infer_const_params() { + check_infer( + r#" + fn foo<const FOO: usize>() { + let bar = FOO; + } + "#, + expect![[r#" + 27..49 '{ ...FOO; }': () + 37..40 'bar': usize + 43..46 'FOO': usize + "#]], + ); +} + +#[test] +fn infer_inner_type() { + check_infer( + r#" + fn foo() { + struct S { field: u32 } + let s = S { field: 0 }; + let f = s.field; + } + "#, + expect![[r#" + 9..89 '{ ...eld; }': () + 47..48 's': S + 51..65 'S { field: 0 }': S + 62..63 '0': u32 + 75..76 'f': u32 + 79..80 's': S + 79..86 's.field': u32 + "#]], + ); +} + +#[test] +fn infer_nested_inner_type() { + check_infer( + r#" + fn foo() { + { + let s = S { field: 0 }; + let f = s.field; + } + struct S { field: u32 } + } + "#, + expect![[r#" + 9..109 '{ ...32 } }': () + 15..79 '{ ... }': () + 29..30 's': S + 33..47 'S { field: 0 }': S + 44..45 '0': u32 + 61..62 'f': u32 + 65..66 's': S + 65..72 's.field': u32 + "#]], + ); +} + +#[test] +fn inner_use_enum_rename() { + check_infer( + r#" + enum Request { + Info + } + + fn f() { + use Request as R; + + let r = R::Info; + match r { + R::Info => {} + } + } + "#, + expect![[r#" + 34..123 '{ ... } }': () + 67..68 'r': Request + 71..78 'R::Info': Request + 84..121 'match ... }': () + 90..91 'r': Request + 102..109 'R::Info': Request + 113..115 '{}': () + "#]], + ) +} + +#[test] +fn box_into_vec() { + check_infer( + r#" +#[lang = "sized"] +pub trait Sized {} + +#[lang = "unsize"] +pub trait Unsize<T: ?Sized> {} + +#[lang = "coerce_unsized"] +pub trait CoerceUnsized<T> {} + +pub unsafe trait Allocator {} + +pub struct Global; +unsafe impl Allocator for Global {} + +#[lang = "owned_box"] +#[fundamental] +pub struct Box<T: ?Sized, A: Allocator = Global>; + +impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A> {} + +pub struct Vec<T, A: Allocator = Global> {} + +#[lang = "slice"] +impl<T> [T] {} + +#[lang = "slice_alloc"] +impl<T> [T] { + pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> { + unimplemented!() + } +} + +fn test() { + let vec = <[_]>::into_vec(box [1i32]); + let v: Vec<Box<dyn B>> = <[_]> :: into_vec(box [box Astruct]); +} + +trait B{} +struct Astruct; +impl B for Astruct {} +"#, + expect![[r#" + 569..573 'self': Box<[T], A> + 602..634 '{ ... }': Vec<T, A> + 612..628 'unimpl...ted!()': Vec<T, A> + 648..761 '{ ...t]); }': () + 658..661 'vec': Vec<i32, Global> + 664..679 '<[_]>::into_vec': fn into_vec<i32, Global>(Box<[i32], Global>) -> Vec<i32, Global> + 664..691 '<[_]>:...1i32])': Vec<i32, Global> + 680..690 'box [1i32]': Box<[i32; 1], Global> + 684..690 '[1i32]': [i32; 1] + 685..689 '1i32': i32 + 701..702 'v': Vec<Box<dyn B, Global>, Global> + 722..739 '<[_]> ...to_vec': fn into_vec<Box<dyn B, Global>, Global>(Box<[Box<dyn B, Global>], Global>) -> Vec<Box<dyn B, Global>, Global> + 722..758 '<[_]> ...ruct])': Vec<Box<dyn B, Global>, Global> + 740..757 'box [b...truct]': Box<[Box<dyn B, Global>; 1], Global> + 744..757 '[box Astruct]': [Box<dyn B, Global>; 1] + 745..756 'box Astruct': Box<Astruct, Global> + 749..756 'Astruct': Astruct + "#]], + ) +} + +#[test] +fn cfgd_out_assoc_items() { + check_types( + r#" +struct S; + +impl S { + #[cfg(FALSE)] + const C: S = S; +} + +fn f() { + S::C; + //^^^^ {unknown} +} + "#, + ) +} + +#[test] +fn infer_missing_type() { + check_types( + r#" +struct S; + +fn f() { + let s: = S; + //^ S +} + "#, + ); +} + +#[test] +fn infer_type_alias_variant() { + check_infer( + r#" +type Qux = Foo; +enum Foo { + Bar(i32), + Baz { baz: f32 } +} + +fn f() { + match Foo::Bar(3) { + Qux::Bar(bar) => (), + Qux::Baz { baz } => (), + } +} + "#, + expect![[r#" + 72..166 '{ ... } }': () + 78..164 'match ... }': () + 84..92 'Foo::Bar': Bar(i32) -> Foo + 84..95 'Foo::Bar(3)': Foo + 93..94 '3': i32 + 106..119 'Qux::Bar(bar)': Foo + 115..118 'bar': i32 + 123..125 '()': () + 135..151 'Qux::B... baz }': Foo + 146..149 'baz': f32 + 155..157 '()': () + "#]], + ) +} + +#[test] +fn infer_boxed_self_receiver() { + check_infer( + r#" +//- minicore: deref +use core::ops::Deref; + +struct Box<T>(T); + +impl<T> Deref for Box<T> { + type Target = T; + fn deref(&self) -> &Self::Target; +} + +struct Foo<T>(T); + +impl<T> Foo<T> { + fn get_inner<'a>(self: &'a Box<Self>) -> &'a T {} + + fn get_self<'a>(self: &'a Box<Self>) -> &'a Self {} + + fn into_inner(self: Box<Self>) -> Self {} +} + +fn main() { + let boxed = Box(Foo(0_i32)); + + let bad1 = boxed.get_inner(); + let good1 = Foo::get_inner(&boxed); + + let bad2 = boxed.get_self(); + let good2 = Foo::get_self(&boxed); + + let inner = boxed.into_inner(); +} + "#, + expect![[r#" + 104..108 'self': &Box<T> + 188..192 'self': &Box<Foo<T>> + 218..220 '{}': &T + 242..246 'self': &Box<Foo<T>> + 275..277 '{}': &Foo<T> + 297..301 'self': Box<Foo<T>> + 322..324 '{}': Foo<T> + 338..559 '{ ...r(); }': () + 348..353 'boxed': Box<Foo<i32>> + 356..359 'Box': Box<Foo<i32>>(Foo<i32>) -> Box<Foo<i32>> + 356..371 'Box(Foo(0_i32))': Box<Foo<i32>> + 360..363 'Foo': Foo<i32>(i32) -> Foo<i32> + 360..370 'Foo(0_i32)': Foo<i32> + 364..369 '0_i32': i32 + 382..386 'bad1': &i32 + 389..394 'boxed': Box<Foo<i32>> + 389..406 'boxed....nner()': &i32 + 416..421 'good1': &i32 + 424..438 'Foo::get_inner': fn get_inner<i32>(&Box<Foo<i32>>) -> &i32 + 424..446 'Foo::g...boxed)': &i32 + 439..445 '&boxed': &Box<Foo<i32>> + 440..445 'boxed': Box<Foo<i32>> + 457..461 'bad2': &Foo<i32> + 464..469 'boxed': Box<Foo<i32>> + 464..480 'boxed....self()': &Foo<i32> + 490..495 'good2': &Foo<i32> + 498..511 'Foo::get_self': fn get_self<i32>(&Box<Foo<i32>>) -> &Foo<i32> + 498..519 'Foo::g...boxed)': &Foo<i32> + 512..518 '&boxed': &Box<Foo<i32>> + 513..518 'boxed': Box<Foo<i32>> + 530..535 'inner': Foo<i32> + 538..543 'boxed': Box<Foo<i32>> + 538..556 'boxed....nner()': Foo<i32> + "#]], + ); +} + +#[test] +fn prelude_2015() { + check_types( + r#" +//- /main.rs edition:2015 crate:main deps:core +fn f() { + Rust; + //^^^^ Rust +} + +//- /core.rs crate:core +pub mod prelude { + pub mod rust_2015 { + pub struct Rust; + } +} + "#, + ); +} + +#[test] +fn legacy_const_generics() { + check_no_mismatches( + r#" +#[rustc_legacy_const_generics(1, 3)] +fn mixed<const N1: &'static str, const N2: bool>( + a: u8, + b: i8, +) {} + +fn f() { + mixed(0, "", -1, true); + mixed::<"", true>(0, -1); +} + "#, + ); +} + +#[test] +fn destructuring_assignment_slice() { + check_types( + r#" +fn main() { + let a; + //^usize + [a,] = [0usize]; + + let a; + //^usize + [a, ..] = [0usize; 5]; + + let a; + //^usize + [.., a] = [0usize; 5]; + + let a; + //^usize + [.., a, _] = [0usize; 5]; + + let a; + //^usize + [_, a, ..] = [0usize; 5]; + + let a: &mut i64 = &mut 0; + [*a, ..] = [1, 2, 3]; + + let a: usize; + let b; + //^usize + [a, _, b] = [3, 4, 5]; + //^usize + + let a; + //^i64 + let b; + //^i64 + [[a, ..], .., [.., b]] = [[1, 2], [3i64, 4], [5, 6], [7, 8]]; +} + "#, + ); +} + +#[test] +fn destructuring_assignment_tuple() { + check_types( + r#" +fn main() { + let a; + //^char + let b; + //^i64 + (a, b) = ('c', 0i64); + + let a; + //^char + (a, ..) = ('c', 0i64); + + let a; + //^i64 + (.., a) = ('c', 0i64); + + let a; + //^char + let b; + //^i64 + (a, .., b) = ('c', 0i64); + + let a; + //^char + let b; + //^bool + (a, .., b) = ('c', 0i64, true); + + let a; + //^i64 + let b; + //^bool + (_, a, .., b) = ('c', 0i64, true); + + let a; + //^i64 + let b; + //^usize + (_, a, .., b) = ('c', 0i64, true, 0usize); + + let mut a = 1; + //^^^^^i64 + let mut b: i64 = 0; + (a, b) = (b, a); +} + "#, + ); +} + +#[test] +fn destructuring_assignment_tuple_struct() { + check_types( + r#" +struct S2(char, i64); +struct S3(char, i64, bool); +struct S4(char, i64, bool usize); +fn main() { + let a; + //^char + let b; + //^i64 + S2(a, b) = S2('c', 0i64); + + let a; + //^char + let b; + //^i64 + S2(a, .., b) = S2('c', 0i64); + + let a; + //^char + let b; + //^bool + S3(a, .., b) = S3('c', 0i64, true); + + let a; + //^i64 + let b; + //^bool + S3(_, a, .., b) = S3('c', 0i64, true); + + let a; + //^i64 + let b; + //^usize + S4(_, a, .., b) = S4('c', 0i64, true, 0usize); + + struct Swap(i64, i64); + + let mut a = 1; + //^^^^^i64 + let mut b = 0; + //^^^^^i64 + Swap(a, b) = Swap(b, a); +} + "#, + ); +} + +#[test] +fn destructuring_assignment_struct() { + check_types( + r#" +struct S { + a: usize, + b: char, +} +struct T { + s: S, + t: i64, +} + +fn main() { + let a; + //^usize + let c; + //^char + S { a, b: c } = S { a: 3, b: 'b' }; + + let a; + //^char + S { b: a, .. } = S { a: 3, b: 'b' }; + + let a; + //^char + S { b: a, _ } = S { a: 3, b: 'b' }; + + let a; + //^usize + let c; + //^char + let t; + //^i64 + T { s: S { a, b: c }, t } = T { s: S { a: 3, b: 'b' }, t: 0 }; +} + "#, + ); +} + +#[test] +fn destructuring_assignment_nested() { + check_types( + r#" +struct S { + a: TS, + b: [char; 3], +} +struct TS(usize, i64); + +fn main() { + let a; + //^i32 + let b; + //^bool + ([.., a], .., b, _) = ([0, 1, 2], true, 'c'); + + let a; + //^i32 + let b; + //^i32 + [(.., a, _), .., (b, ..)] = [(1, 2); 5]; + + let a; + //^usize + let b; + //^char + S { a: TS(a, ..), b: [_, b, ..] } = S { a: TS(0, 0), b: ['a'; 3] }; +} + "#, + ); +} + +#[test] +fn destructuring_assignment_unit_struct() { + // taken from rustc; see https://github.com/rust-lang/rust/pull/95380 + check_no_mismatches( + r#" +struct S; +enum E { V, } +type A = E; + +fn main() { + let mut a; + + (S, a) = (S, ()); + + (E::V, a) = (E::V, ()); + + (<E>::V, a) = (E::V, ()); + (A::V, a) = (E::V, ()); +} + +impl S { + fn check() { + let a; + (Self, a) = (S, ()); + } +} + +impl E { + fn check() { + let a; + (Self::V, a) = (E::V, ()); + } +} + "#, + ); +} + +#[test] +fn destructuring_assignment_no_default_binding_mode() { + check( + r#" +struct S { a: usize } +struct TS(usize); +fn main() { + let x; + [x,] = &[1,]; + //^^^^expected &[i32; 1], got [{unknown}; _] + + // FIXME we only want the outermost error, but this matches the current + // behavior of slice patterns + let x; + [(x,),] = &[(1,),]; + // ^^^^expected {unknown}, got ({unknown},) + //^^^^^^^expected &[(i32,); 1], got [{unknown}; _] + + let x; + ((x,),) = &((1,),); + //^^^^^^^expected &((i32,),), got (({unknown},),) + + let x; + (x,) = &(1,); + //^^^^expected &(i32,), got ({unknown},) + + let x; + (S { a: x },) = &(S { a: 42 },); + //^^^^^^^^^^^^^expected &(S,), got (S,) + + let x; + S { a: x } = &S { a: 42 }; + //^^^^^^^^^^expected &S, got S + + let x; + TS(x) = &TS(42); + //^^^^^expected &TS, got TS +} + "#, + ); +} + +#[test] +fn destructuring_assignment_type_mismatch_on_identifier() { + check( + r#" +struct S { v: i64 } +struct TS(i64); +fn main() { + let mut a: usize = 0; + (a,) = (0i64,); + //^expected i64, got usize + + let mut a: usize = 0; + [a,] = [0i64,]; + //^expected i64, got usize + + let mut a: usize = 0; + S { v: a } = S { v: 0 }; + //^expected i64, got usize + + let mut a: usize = 0; + TS(a) = TS(0); + //^expected i64, got usize +} + "#, + ); +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs new file mode 100644 index 000000000..75802a5eb --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs @@ -0,0 +1,3782 @@ +use cov_mark::check; +use expect_test::expect; + +use super::{check, check_infer, check_infer_with_mismatches, check_no_mismatches, check_types}; + +#[test] +fn infer_await() { + check_types( + r#" +//- minicore: future +struct IntFuture; + +impl core::future::Future for IntFuture { + type Output = u64; +} + +fn test() { + let r = IntFuture; + let v = r.await; + v; +} //^ u64 +"#, + ); +} + +#[test] +fn infer_async() { + check_types( + r#" +//- minicore: future +async fn foo() -> u64 { 128 } + +fn test() { + let r = foo(); + let v = r.await; + v; +} //^ u64 +"#, + ); +} + +#[test] +fn infer_desugar_async() { + check_types( + r#" +//- minicore: future, sized +async fn foo() -> u64 { 128 } + +fn test() { + let r = foo(); + r; +} //^ impl Future<Output = u64> +"#, + ); +} + +#[test] +fn infer_async_block() { + check_types( + r#" +//- minicore: future, option +async fn test() { + let a = async { 42 }; + a; +// ^ impl Future<Output = i32> + let x = a.await; + x; +// ^ i32 + let b = async {}.await; + b; +// ^ () + let c = async { + let y = None; + y + // ^ Option<u64> + }; + let _: Option<u64> = c.await; + c; +// ^ impl Future<Output = Option<u64>> +} +"#, + ); +} + +#[test] +fn auto_sized_async_block() { + check_no_mismatches( + r#" +//- minicore: future, sized + +use core::future::Future; +struct MyFut<Fut>(Fut); + +impl<Fut> Future for MyFut<Fut> +where Fut: Future +{ + type Output = Fut::Output; +} +async fn reproduction() -> usize { + let f = async {999usize}; + MyFut(f).await +} + "#, + ); + check_no_mismatches( + r#" +//- minicore: future +//#11815 +#[lang = "sized"] +pub trait Sized {} + +#[lang = "unsize"] +pub trait Unsize<T: ?Sized> {} + +#[lang = "coerce_unsized"] +pub trait CoerceUnsized<T> {} + +pub unsafe trait Allocator {} + +pub struct Global; +unsafe impl Allocator for Global {} + +#[lang = "owned_box"] +#[fundamental] +pub struct Box<T: ?Sized, A: Allocator = Global>; + +impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A> {} + +fn send() -> Box<dyn Future<Output = ()> + Send + 'static>{ + box async move {} +} + +fn not_send() -> Box<dyn Future<Output = ()> + 'static> { + box async move {} +} + "#, + ); +} + +#[test] +fn infer_try() { + check_types( + r#" +//- /main.rs crate:main deps:core +fn test() { + let r: Result<i32, u64> = Result::Ok(1); + let v = r?; + v; +} //^ i32 + +//- /core.rs crate:core +pub mod ops { + pub trait Try { + type Ok; + type Error; + } +} + +pub mod result { + pub enum Result<O, E> { + Ok(O), + Err(E) + } + + impl<O, E> crate::ops::Try for Result<O, E> { + type Ok = O; + type Error = E; + } +} + +pub mod prelude { + pub mod rust_2018 { + pub use crate::{result::*, ops::*}; + } +} +"#, + ); +} + +#[test] +fn infer_try_trait_v2() { + check_types( + r#" +//- /main.rs crate:main deps:core +fn test() { + let r: Result<i32, u64> = Result::Ok(1); + let v = r?; + v; +} //^ i32 + +//- /core.rs crate:core +mod ops { + mod try_trait { + pub trait Try: FromResidual { + type Output; + type Residual; + } + pub trait FromResidual<R = <Self as Try>::Residual> {} + } + + pub use self::try_trait::FromResidual; + pub use self::try_trait::Try; +} + +mod convert { + pub trait From<T> {} + impl<T> From<T> for T {} +} + +pub mod result { + use crate::convert::From; + use crate::ops::{Try, FromResidual}; + + pub enum Infallible {} + pub enum Result<O, E> { + Ok(O), + Err(E) + } + + impl<O, E> Try for Result<O, E> { + type Output = O; + type Error = Result<Infallible, E>; + } + + impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F> {} +} + +pub mod prelude { + pub mod rust_2018 { + pub use crate::result::*; + } +} +"#, + ); +} + +#[test] +fn infer_for_loop() { + check_types( + r#" +//- /main.rs crate:main deps:core,alloc +#![no_std] +use alloc::collections::Vec; + +fn test() { + let v = Vec::new(); + v.push("foo"); + for x in v { + x; + } //^ &str +} + +//- /core.rs crate:core +pub mod iter { + pub trait IntoIterator { + type Item; + } +} +pub mod prelude { + pub mod rust_2018 { + pub use crate::iter::*; + } +} + +//- /alloc.rs crate:alloc deps:core +#![no_std] +pub mod collections { + pub struct Vec<T> {} + impl<T> Vec<T> { + pub fn new() -> Self { Vec {} } + pub fn push(&mut self, t: T) { } + } + + impl<T> IntoIterator for Vec<T> { + type Item=T; + } +} +"#, + ); +} + +#[test] +fn infer_ops_neg() { + check_types( + r#" +//- /main.rs crate:main deps:std +struct Bar; +struct Foo; + +impl std::ops::Neg for Bar { + type Output = Foo; +} + +fn test() { + let a = Bar; + let b = -a; + b; +} //^ Foo + +//- /std.rs crate:std +#[prelude_import] use ops::*; +mod ops { + #[lang = "neg"] + pub trait Neg { + type Output; + } +} +"#, + ); +} + +#[test] +fn infer_ops_not() { + check_types( + r#" +//- /main.rs crate:main deps:std +struct Bar; +struct Foo; + +impl std::ops::Not for Bar { + type Output = Foo; +} + +fn test() { + let a = Bar; + let b = !a; + b; +} //^ Foo + +//- /std.rs crate:std +#[prelude_import] use ops::*; +mod ops { + #[lang = "not"] + pub trait Not { + type Output; + } +} +"#, + ); +} + +#[test] +fn infer_from_bound_1() { + check_types( + r#" +trait Trait<T> {} +struct S<T>(T); +impl<U> Trait<U> for S<U> {} +fn foo<T: Trait<u32>>(t: T) {} +fn test() { + let s = S(unknown); + // ^^^^^^^ u32 + foo(s); +}"#, + ); +} + +#[test] +fn infer_from_bound_2() { + check_types( + r#" +trait Trait<T> {} +struct S<T>(T); +impl<U> Trait<U> for S<U> {} +fn foo<U, T: Trait<U>>(t: T) -> U { loop {} } +fn test() { + let s = S(unknown); + // ^^^^^^^ u32 + let x: u32 = foo(s); +}"#, + ); +} + +#[test] +fn trait_default_method_self_bound_implements_trait() { + cov_mark::check!(trait_self_implements_self); + check( + r#" +trait Trait { + fn foo(&self) -> i64; + fn bar(&self) -> () { + self.foo(); + // ^^^^^^^^^^ type: i64 + } +}"#, + ); +} + +#[test] +fn trait_default_method_self_bound_implements_super_trait() { + check( + r#" +trait SuperTrait { + fn foo(&self) -> i64; +} +trait Trait: SuperTrait { + fn bar(&self) -> () { + self.foo(); + // ^^^^^^^^^^ type: i64 + } +}"#, + ); +} + +#[test] +fn infer_project_associated_type() { + check_types( + r#" +trait Iterable { + type Item; +} +struct S; +impl Iterable for S { type Item = u32; } +fn test<T: Iterable>() { + let x: <S as Iterable>::Item = 1; + // ^ u32 + let y: <T as Iterable>::Item = u; + // ^ Iterable::Item<T> + let z: T::Item = u; + // ^ Iterable::Item<T> + let a: <T>::Item = u; + // ^ Iterable::Item<T> +}"#, + ); +} + +#[test] +fn infer_return_associated_type() { + check_types( + r#" +trait Iterable { + type Item; +} +struct S; +impl Iterable for S { type Item = u32; } +fn foo1<T: Iterable>(t: T) -> T::Item { loop {} } +fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item { loop {} } +fn foo3<T: Iterable>(t: T) -> <T>::Item { loop {} } +fn test() { + foo1(S); + // ^^^^^^^ u32 + foo2(S); + // ^^^^^^^ u32 + foo3(S); + // ^^^^^^^ u32 +}"#, + ); +} + +#[test] +fn associated_type_shorthand_from_method_bound() { + check_types( + r#" +trait Iterable { + type Item; +} +struct S<T>; +impl<T> S<T> { + fn foo(self) -> T::Item where T: Iterable { loop {} } +} +fn test<T: Iterable>() { + let s: S<T>; + s.foo(); + // ^^^^^^^ Iterable::Item<T> +}"#, + ); +} + +#[test] +fn associated_type_shorthand_from_self_issue_12484() { + check_types( + r#" +trait Bar { + type A; +} +trait Foo { + type A; + fn test(a: Self::A, _: impl Bar) { + a; + //^ Foo::A<Self> + } +}"#, + ); +} + +#[test] +fn infer_associated_type_bound() { + check_types( + r#" +trait Iterable { + type Item; +} +fn test<T: Iterable<Item=u32>>() { + let y: T::Item = unknown; + // ^^^^^^^ u32 +}"#, + ); +} + +#[test] +fn infer_const_body() { + // FIXME make check_types work with other bodies + check_infer( + r#" +const A: u32 = 1 + 1; +static B: u64 = { let x = 1; x }; +"#, + expect![[r#" + 15..16 '1': u32 + 15..20 '1 + 1': u32 + 19..20 '1': u32 + 38..54 '{ let ...1; x }': u64 + 44..45 'x': u64 + 48..49 '1': u64 + 51..52 'x': u64 + "#]], + ); +} + +#[test] +fn tuple_struct_fields() { + check_infer( + r#" +struct S(i32, u64); +fn test() -> u64 { + let a = S(4, 6); + let b = a.0; + a.1 +}"#, + expect![[r#" + 37..86 '{ ... a.1 }': u64 + 47..48 'a': S + 51..52 'S': S(i32, u64) -> S + 51..58 'S(4, 6)': S + 53..54 '4': i32 + 56..57 '6': u64 + 68..69 'b': i32 + 72..73 'a': S + 72..75 'a.0': i32 + 81..82 'a': S + 81..84 'a.1': u64 + "#]], + ); +} + +#[test] +fn tuple_struct_with_fn() { + check_infer( + r#" +struct S(fn(u32) -> u64); +fn test() -> u64 { + let a = S(|i| 2*i); + let b = a.0(4); + a.0(2) +}"#, + expect![[r#" + 43..101 '{ ...0(2) }': u64 + 53..54 'a': S + 57..58 'S': S(fn(u32) -> u64) -> S + 57..67 'S(|i| 2*i)': S + 59..66 '|i| 2*i': |u32| -> u64 + 60..61 'i': u32 + 63..64 '2': u32 + 63..66 '2*i': u32 + 65..66 'i': u32 + 77..78 'b': u64 + 81..82 'a': S + 81..84 'a.0': fn(u32) -> u64 + 81..87 'a.0(4)': u64 + 85..86 '4': u32 + 93..94 'a': S + 93..96 'a.0': fn(u32) -> u64 + 93..99 'a.0(2)': u64 + 97..98 '2': u32 + "#]], + ); +} + +#[test] +fn indexing_arrays() { + check_infer( + "fn main() { &mut [9][2]; }", + expect![[r#" + 10..26 '{ &mut...[2]; }': () + 12..23 '&mut [9][2]': &mut {unknown} + 17..20 '[9]': [i32; 1] + 17..23 '[9][2]': {unknown} + 18..19 '9': i32 + 21..22 '2': i32 + "#]], + ) +} + +#[test] +fn infer_ops_index() { + check_types( + r#" +//- minicore: index +struct Bar; +struct Foo; + +impl core::ops::Index<u32> for Bar { + type Output = Foo; +} + +fn test() { + let a = Bar; + let b = a[1u32]; + b; +} //^ Foo +"#, + ); +} + +#[test] +fn infer_ops_index_field() { + check_types( + r#" +//- minicore: index +struct Bar; +struct Foo { + field: u32; +} + +impl core::ops::Index<u32> for Bar { + type Output = Foo; +} + +fn test() { + let a = Bar; + let b = a[1u32].field; + b; +} //^ u32 +"#, + ); +} + +#[test] +fn infer_ops_index_field_autoderef() { + check_types( + r#" +//- minicore: index +struct Bar; +struct Foo { + field: u32; +} + +impl core::ops::Index<u32> for Bar { + type Output = Foo; +} + +fn test() { + let a = Bar; + let b = (&a[1u32]).field; + b; +} //^ u32 +"#, + ); +} + +#[test] +fn infer_ops_index_int() { + check_types( + r#" +//- minicore: index +struct Bar; +struct Foo; + +impl core::ops::Index<u32> for Bar { + type Output = Foo; +} + +struct Range; +impl core::ops::Index<Range> for Bar { + type Output = Bar; +} + +fn test() { + let a = Bar; + let b = a[1]; + b; + //^ Foo +} +"#, + ); +} + +#[test] +fn infer_ops_index_autoderef() { + check_types( + r#" +//- minicore: index, slice +fn test() { + let a = &[1u32, 2, 3]; + let b = a[1]; + b; +} //^ u32 +"#, + ); +} + +#[test] +fn deref_trait() { + check_types( + r#" +//- minicore: deref +struct Arc<T: ?Sized>; +impl<T: ?Sized> core::ops::Deref for Arc<T> { + type Target = T; +} + +struct S; +impl S { + fn foo(&self) -> u128 { 0 } +} + +fn test(s: Arc<S>) { + (*s, s.foo()); +} //^^^^^^^^^^^^^ (S, u128) +"#, + ); +} + +#[test] +fn deref_trait_with_inference_var() { + check_types( + r#" +//- minicore: deref +struct Arc<T: ?Sized>; +fn new_arc<T: ?Sized>() -> Arc<T> { Arc } +impl<T: ?Sized> core::ops::Deref for Arc<T> { + type Target = T; +} + +struct S; +fn foo(a: Arc<S>) {} + +fn test() { + let a = new_arc(); + let b = *a; + //^^ S + foo(a); +} +"#, + ); +} + +#[test] +fn deref_trait_infinite_recursion() { + check_types( + r#" +//- minicore: deref +struct S; + +impl core::ops::Deref for S { + type Target = S; +} + +fn test(s: S) { + s.foo(); +} //^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn deref_trait_with_question_mark_size() { + check_types( + r#" +//- minicore: deref +struct Arc<T: ?Sized>; +impl<T: ?Sized> core::ops::Deref for Arc<T> { + type Target = T; +} + +struct S; +impl S { + fn foo(&self) -> u128 { 0 } +} + +fn test(s: Arc<S>) { + (*s, s.foo()); +} //^^^^^^^^^^^^^ (S, u128) +"#, + ); +} + +#[test] +fn deref_trait_with_implicit_sized_requirement_on_inference_var() { + check_types( + r#" +//- minicore: deref +struct Foo<T>; +impl<T> core::ops::Deref for Foo<T> { + type Target = (); +} +fn test() { + let foo = Foo; + *foo; + //^^^^ () + let _: Foo<u8> = foo; +} +"#, + ) +} + +#[test] +fn obligation_from_function_clause() { + check_types( + r#" +struct S; + +trait Trait<T> {} +impl Trait<u32> for S {} + +fn foo<T: Trait<U>, U>(t: T) -> U { loop {} } + +fn test(s: S) { + foo(s); +} //^^^^^^ u32 +"#, + ); +} + +#[test] +fn obligation_from_method_clause() { + check_types( + r#" +//- /main.rs +struct S; + +trait Trait<T> {} +impl Trait<isize> for S {} + +struct O; +impl O { + fn foo<T: Trait<U>, U>(&self, t: T) -> U { loop {} } +} + +fn test() { + O.foo(S); +} //^^^^^^^^ isize +"#, + ); +} + +#[test] +fn obligation_from_self_method_clause() { + check_types( + r#" +struct S; + +trait Trait<T> {} +impl Trait<i64> for S {} + +impl S { + fn foo<U>(&self) -> U where Self: Trait<U> { loop {} } +} + +fn test() { + S.foo(); +} //^^^^^^^ i64 +"#, + ); +} + +#[test] +fn obligation_from_impl_clause() { + check_types( + r#" +struct S; + +trait Trait<T> {} +impl Trait<&str> for S {} + +struct O<T>; +impl<U, T: Trait<U>> O<T> { + fn foo(&self) -> U { loop {} } +} + +fn test(o: O<S>) { + o.foo(); +} //^^^^^^^ &str +"#, + ); +} + +#[test] +fn generic_param_env_1() { + check_types( + r#" +trait Clone {} +trait Trait { fn foo(self) -> u128; } +struct S; +impl Clone for S {} +impl<T> Trait for T where T: Clone {} +fn test<T: Clone>(t: T) { t.foo(); } + //^^^^^^^ u128 +"#, + ); +} + +#[test] +fn generic_param_env_1_not_met() { + check_types( + r#" +//- /main.rs +trait Clone {} +trait Trait { fn foo(self) -> u128; } +struct S; +impl Clone for S {} +impl<T> Trait for T where T: Clone {} +fn test<T>(t: T) { t.foo(); } + //^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn generic_param_env_2() { + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl Trait for S {} +fn test<T: Trait>(t: T) { t.foo(); } + //^^^^^^^ u128 +"#, + ); +} + +#[test] +fn generic_param_env_2_not_met() { + check_types( + r#" +trait Trait { fn foo(self) -> u128; } +struct S; +impl Trait for S {} +fn test<T>(t: T) { t.foo(); } + //^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn generic_param_env_deref() { + check_types( + r#" +//- minicore: deref +trait Trait {} +impl<T> core::ops::Deref for T where T: Trait { + type Target = i128; +} +fn test<T: Trait>(t: T) { *t; } + //^^ i128 +"#, + ); +} + +#[test] +fn associated_type_placeholder() { + // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types]. + check_types( + r#" +pub trait ApplyL { + type Out; +} + +pub struct RefMutL<T>; + +impl<T> ApplyL for RefMutL<T> { + type Out = <T as ApplyL>::Out; +} + +fn test<T: ApplyL>() { + let y: <RefMutL<T> as ApplyL>::Out = no_matter; + y; +} //^ ApplyL::Out<T> +"#, + ); +} + +#[test] +fn associated_type_placeholder_2() { + check_types( + r#" +pub trait ApplyL { + type Out; +} +fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out; + +fn test<T: ApplyL>(t: T) { + let y = foo(t); + y; +} //^ ApplyL::Out<T> +"#, + ); +} + +#[test] +fn argument_impl_trait() { + check_infer_with_mismatches( + r#" +//- minicore: sized +trait Trait<T> { + fn foo(&self) -> T; + fn foo2(&self) -> i64; +} +fn bar(x: impl Trait<u16>) {} +struct S<T>(T); +impl<T> Trait<T> for S<T> {} + +fn test(x: impl Trait<u64>, y: &impl Trait<u32>) { + x; + y; + let z = S(1); + bar(z); + x.foo(); + y.foo(); + z.foo(); + x.foo2(); + y.foo2(); + z.foo2(); +}"#, + expect![[r#" + 29..33 'self': &Self + 54..58 'self': &Self + 77..78 'x': impl Trait<u16> + 97..99 '{}': () + 154..155 'x': impl Trait<u64> + 174..175 'y': &impl Trait<u32> + 195..323 '{ ...2(); }': () + 201..202 'x': impl Trait<u64> + 208..209 'y': &impl Trait<u32> + 219..220 'z': S<u16> + 223..224 'S': S<u16>(u16) -> S<u16> + 223..227 'S(1)': S<u16> + 225..226 '1': u16 + 233..236 'bar': fn bar(S<u16>) + 233..239 'bar(z)': () + 237..238 'z': S<u16> + 245..246 'x': impl Trait<u64> + 245..252 'x.foo()': u64 + 258..259 'y': &impl Trait<u32> + 258..265 'y.foo()': u32 + 271..272 'z': S<u16> + 271..278 'z.foo()': u16 + 284..285 'x': impl Trait<u64> + 284..292 'x.foo2()': i64 + 298..299 'y': &impl Trait<u32> + 298..306 'y.foo2()': i64 + 312..313 'z': S<u16> + 312..320 'z.foo2()': i64 + "#]], + ); +} + +#[test] +fn argument_impl_trait_type_args_1() { + check_infer_with_mismatches( + r#" +//- minicore: sized +trait Trait {} +trait Foo { + // this function has an implicit Self param, an explicit type param, + // and an implicit impl Trait param! + fn bar<T>(x: impl Trait) -> T { loop {} } +} +fn foo<T>(x: impl Trait) -> T { loop {} } +struct S; +impl Trait for S {} +struct F; +impl Foo for F {} + +fn test() { + Foo::bar(S); + <F as Foo>::bar(S); + F::bar(S); + Foo::bar::<u32>(S); + <F as Foo>::bar::<u32>(S); + + foo(S); + foo::<u32>(S); + foo::<u32, i32>(S); // we should ignore the extraneous i32 +}"#, + expect![[r#" + 155..156 'x': impl Trait + 175..186 '{ loop {} }': T + 177..184 'loop {}': ! + 182..184 '{}': () + 199..200 'x': impl Trait + 219..230 '{ loop {} }': T + 221..228 'loop {}': ! + 226..228 '{}': () + 300..509 '{ ... i32 }': () + 306..314 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown} + 306..317 'Foo::bar(S)': {unknown} + 315..316 'S': S + 323..338 '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown} + 323..341 '<F as ...bar(S)': {unknown} + 339..340 'S': S + 347..353 'F::bar': fn bar<F, {unknown}>(S) -> {unknown} + 347..356 'F::bar(S)': {unknown} + 354..355 'S': S + 362..377 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32 + 362..380 'Foo::b...32>(S)': u32 + 378..379 'S': S + 386..408 '<F as ...:<u32>': fn bar<F, u32>(S) -> u32 + 386..411 '<F as ...32>(S)': u32 + 409..410 'S': S + 418..421 'foo': fn foo<{unknown}>(S) -> {unknown} + 418..424 'foo(S)': {unknown} + 422..423 'S': S + 430..440 'foo::<u32>': fn foo<u32>(S) -> u32 + 430..443 'foo::<u32>(S)': u32 + 441..442 'S': S + 449..464 'foo::<u32, i32>': fn foo<u32>(S) -> u32 + 449..467 'foo::<...32>(S)': u32 + 465..466 'S': S + "#]], + ); +} + +#[test] +fn argument_impl_trait_type_args_2() { + check_infer_with_mismatches( + r#" +//- minicore: sized +trait Trait {} +struct S; +impl Trait for S {} +struct F<T>; +impl<T> F<T> { + fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} } +} + +fn test() { + F.foo(S); + F::<u32>.foo(S); + F::<u32>.foo::<i32>(S); + F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored +}"#, + expect![[r#" + 87..91 'self': F<T> + 93..94 'x': impl Trait + 118..129 '{ loop {} }': (T, U) + 120..127 'loop {}': ! + 125..127 '{}': () + 143..283 '{ ...ored }': () + 149..150 'F': F<{unknown}> + 149..157 'F.foo(S)': ({unknown}, {unknown}) + 155..156 'S': S + 163..171 'F::<u32>': F<u32> + 163..178 'F::<u32>.foo(S)': (u32, {unknown}) + 176..177 'S': S + 184..192 'F::<u32>': F<u32> + 184..206 'F::<u3...32>(S)': (u32, i32) + 204..205 'S': S + 212..220 'F::<u32>': F<u32> + 212..239 'F::<u3...32>(S)': (u32, i32) + 237..238 'S': S + "#]], + ); +} + +#[test] +fn argument_impl_trait_to_fn_pointer() { + check_infer_with_mismatches( + r#" +//- minicore: sized +trait Trait {} +fn foo(x: impl Trait) { loop {} } +struct S; +impl Trait for S {} + +fn test() { + let f: fn(S) -> () = foo; +}"#, + expect![[r#" + 22..23 'x': impl Trait + 37..48 '{ loop {} }': () + 39..46 'loop {}': ! + 44..46 '{}': () + 90..123 '{ ...foo; }': () + 100..101 'f': fn(S) + 117..120 'foo': fn foo(S) + "#]], + ); +} + +#[test] +fn impl_trait() { + check_infer( + r#" +//- minicore: sized +trait Trait<T> { + fn foo(&self) -> T; + fn foo2(&self) -> i64; +} +fn bar() -> impl Trait<u64> {} + +fn test(x: impl Trait<u64>, y: &impl Trait<u64>) { + x; + y; + let z = bar(); + x.foo(); + y.foo(); + z.foo(); + x.foo2(); + y.foo2(); + z.foo2(); +}"#, + expect![[r#" + 29..33 'self': &Self + 54..58 'self': &Self + 98..100 '{}': () + 110..111 'x': impl Trait<u64> + 130..131 'y': &impl Trait<u64> + 151..268 '{ ...2(); }': () + 157..158 'x': impl Trait<u64> + 164..165 'y': &impl Trait<u64> + 175..176 'z': impl Trait<u64> + 179..182 'bar': fn bar() -> impl Trait<u64> + 179..184 'bar()': impl Trait<u64> + 190..191 'x': impl Trait<u64> + 190..197 'x.foo()': u64 + 203..204 'y': &impl Trait<u64> + 203..210 'y.foo()': u64 + 216..217 'z': impl Trait<u64> + 216..223 'z.foo()': u64 + 229..230 'x': impl Trait<u64> + 229..237 'x.foo2()': i64 + 243..244 'y': &impl Trait<u64> + 243..251 'y.foo2()': i64 + 257..258 'z': impl Trait<u64> + 257..265 'z.foo2()': i64 + "#]], + ); +} + +#[test] +fn simple_return_pos_impl_trait() { + cov_mark::check!(lower_rpit); + check_infer( + r#" +//- minicore: sized +trait Trait<T> { + fn foo(&self) -> T; +} +fn bar() -> impl Trait<u64> { loop {} } + +fn test() { + let a = bar(); + a.foo(); +}"#, + expect![[r#" + 29..33 'self': &Self + 71..82 '{ loop {} }': ! + 73..80 'loop {}': ! + 78..80 '{}': () + 94..129 '{ ...o(); }': () + 104..105 'a': impl Trait<u64> + 108..111 'bar': fn bar() -> impl Trait<u64> + 108..113 'bar()': impl Trait<u64> + 119..120 'a': impl Trait<u64> + 119..126 'a.foo()': u64 + "#]], + ); +} + +#[test] +fn more_return_pos_impl_trait() { + check_infer( + r#" +//- minicore: sized +trait Iterator { + type Item; + fn next(&mut self) -> Self::Item; +} +trait Trait<T> { + fn foo(&self) -> T; +} +fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) { loop {} } +fn baz<T>(t: T) -> (impl Iterator<Item = impl Trait<T>>, impl Trait<T>) { loop {} } + +fn test() { + let (a, b) = bar(); + a.next().foo(); + b.foo(); + let (c, d) = baz(1u128); + c.next().foo(); + d.foo(); +}"#, + expect![[r#" + 49..53 'self': &mut Self + 101..105 'self': &Self + 184..195 '{ loop {} }': ({unknown}, {unknown}) + 186..193 'loop {}': ! + 191..193 '{}': () + 206..207 't': T + 268..279 '{ loop {} }': ({unknown}, {unknown}) + 270..277 'loop {}': ! + 275..277 '{}': () + 291..413 '{ ...o(); }': () + 301..307 '(a, b)': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) + 302..303 'a': impl Iterator<Item = impl Trait<u32>> + 305..306 'b': impl Trait<u64> + 310..313 'bar': fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) + 310..315 'bar()': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) + 321..322 'a': impl Iterator<Item = impl Trait<u32>> + 321..329 'a.next()': impl Trait<u32> + 321..335 'a.next().foo()': u32 + 341..342 'b': impl Trait<u64> + 341..348 'b.foo()': u64 + 358..364 '(c, d)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>) + 359..360 'c': impl Iterator<Item = impl Trait<u128>> + 362..363 'd': impl Trait<u128> + 367..370 'baz': fn baz<u128>(u128) -> (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>) + 367..377 'baz(1u128)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>) + 371..376 '1u128': u128 + 383..384 'c': impl Iterator<Item = impl Trait<u128>> + 383..391 'c.next()': impl Trait<u128> + 383..397 'c.next().foo()': u128 + 403..404 'd': impl Trait<u128> + 403..410 'd.foo()': u128 + "#]], + ); +} + +#[test] +fn infer_from_return_pos_impl_trait() { + check_infer_with_mismatches( + r#" +//- minicore: fn, sized +trait Trait<T> {} +struct Bar<T>(T); +impl<T> Trait<T> for Bar<T> {} +fn foo<const C: u8, T>() -> (impl FnOnce(&str, T), impl Trait<u8>) { + (|input, t| {}, Bar(C)) +} +"#, + expect![[r#" + 134..165 '{ ...(C)) }': (|&str, T| -> (), Bar<u8>) + 140..163 '(|inpu...ar(C))': (|&str, T| -> (), Bar<u8>) + 141..154 '|input, t| {}': |&str, T| -> () + 142..147 'input': &str + 149..150 't': T + 152..154 '{}': () + 156..159 'Bar': Bar<u8>(u8) -> Bar<u8> + 156..162 'Bar(C)': Bar<u8> + 160..161 'C': u8 + "#]], + ); +} + +#[test] +fn dyn_trait() { + check_infer( + r#" +//- minicore: sized +trait Trait<T> { + fn foo(&self) -> T; + fn foo2(&self) -> i64; +} +fn bar() -> dyn Trait<u64> {} + +fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) { + x; + y; + let z = bar(); + x.foo(); + y.foo(); + z.foo(); + x.foo2(); + y.foo2(); + z.foo2(); +}"#, + expect![[r#" + 29..33 'self': &Self + 54..58 'self': &Self + 97..99 '{}': dyn Trait<u64> + 109..110 'x': dyn Trait<u64> + 128..129 'y': &dyn Trait<u64> + 148..265 '{ ...2(); }': () + 154..155 'x': dyn Trait<u64> + 161..162 'y': &dyn Trait<u64> + 172..173 'z': dyn Trait<u64> + 176..179 'bar': fn bar() -> dyn Trait<u64> + 176..181 'bar()': dyn Trait<u64> + 187..188 'x': dyn Trait<u64> + 187..194 'x.foo()': u64 + 200..201 'y': &dyn Trait<u64> + 200..207 'y.foo()': u64 + 213..214 'z': dyn Trait<u64> + 213..220 'z.foo()': u64 + 226..227 'x': dyn Trait<u64> + 226..234 'x.foo2()': i64 + 240..241 'y': &dyn Trait<u64> + 240..248 'y.foo2()': i64 + 254..255 'z': dyn Trait<u64> + 254..262 'z.foo2()': i64 + "#]], + ); +} + +#[test] +fn dyn_trait_in_impl() { + check_infer( + r#" +//- minicore: sized +trait Trait<T, U> { + fn foo(&self) -> (T, U); +} +struct S<T, U> {} +impl<T, U> S<T, U> { + fn bar(&self) -> &dyn Trait<T, U> { loop {} } +} +trait Trait2<T, U> { + fn baz(&self) -> (T, U); +} +impl<T, U> Trait2<T, U> for dyn Trait<T, U> { } + +fn test(s: S<u32, i32>) { + s.bar().baz(); +}"#, + expect![[r#" + 32..36 'self': &Self + 102..106 'self': &S<T, U> + 128..139 '{ loop {} }': &dyn Trait<T, U> + 130..137 'loop {}': ! + 135..137 '{}': () + 175..179 'self': &Self + 251..252 's': S<u32, i32> + 267..289 '{ ...z(); }': () + 273..274 's': S<u32, i32> + 273..280 's.bar()': &dyn Trait<u32, i32> + 273..286 's.bar().baz()': (u32, i32) + "#]], + ); +} + +#[test] +fn dyn_trait_bare() { + check_infer( + r#" +//- minicore: sized +trait Trait { + fn foo(&self) -> u64; +} +fn bar() -> Trait {} + +fn test(x: Trait, y: &Trait) -> u64 { + x; + y; + let z = bar(); + x.foo(); + y.foo(); + z.foo(); +}"#, + expect![[r#" + 26..30 'self': &Self + 60..62 '{}': dyn Trait + 72..73 'x': dyn Trait + 82..83 'y': &dyn Trait + 100..175 '{ ...o(); }': u64 + 106..107 'x': dyn Trait + 113..114 'y': &dyn Trait + 124..125 'z': dyn Trait + 128..131 'bar': fn bar() -> dyn Trait + 128..133 'bar()': dyn Trait + 139..140 'x': dyn Trait + 139..146 'x.foo()': u64 + 152..153 'y': &dyn Trait + 152..159 'y.foo()': u64 + 165..166 'z': dyn Trait + 165..172 'z.foo()': u64 + "#]], + ); +} + +#[test] +fn weird_bounds() { + check_infer( + r#" +//- minicore: sized +trait Trait {} +fn test( + a: impl Trait + 'lifetime, + b: impl 'lifetime, + c: impl (Trait), + d: impl ('lifetime), + e: impl ?Sized, + f: impl Trait + ?Sized +) {} +"#, + expect![[r#" + 28..29 'a': impl Trait + 59..60 'b': impl Sized + 82..83 'c': impl Trait + 103..104 'd': impl Sized + 128..129 'e': impl ?Sized + 148..149 'f': impl Trait + ?Sized + 173..175 '{}': () + "#]], + ); +} + +#[test] +fn error_bound_chalk() { + check_types( + r#" +trait Trait { + fn foo(&self) -> u32 { 0 } +} + +fn test(x: (impl Trait + UnknownTrait)) { + x.foo(); +} //^^^^^^^ u32 +"#, + ); +} + +#[test] +fn assoc_type_bindings() { + check_infer( + r#" +//- minicore: sized +trait Trait { + type Type; +} + +fn get<T: Trait>(t: T) -> <T as Trait>::Type {} +fn get2<U, T: Trait<Type = U>>(t: T) -> U {} +fn set<T: Trait<Type = u64>>(t: T) -> T {t} + +struct S<T>; +impl<T> Trait for S<T> { type Type = T; } + +fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) { + get(x); + get2(x); + get(y); + get2(y); + get(set(S)); + get2(set(S)); + get2(S::<str>); +}"#, + expect![[r#" + 49..50 't': T + 77..79 '{}': Trait::Type<T> + 111..112 't': T + 122..124 '{}': U + 154..155 't': T + 165..168 '{t}': T + 166..167 't': T + 256..257 'x': T + 262..263 'y': impl Trait<Type = i64> + 289..397 '{ ...r>); }': () + 295..298 'get': fn get<T>(T) -> <T as Trait>::Type + 295..301 'get(x)': u32 + 299..300 'x': T + 307..311 'get2': fn get2<u32, T>(T) -> u32 + 307..314 'get2(x)': u32 + 312..313 'x': T + 320..323 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type + 320..326 'get(y)': i64 + 324..325 'y': impl Trait<Type = i64> + 332..336 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64 + 332..339 'get2(y)': i64 + 337..338 'y': impl Trait<Type = i64> + 345..348 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type + 345..356 'get(set(S))': u64 + 349..352 'set': fn set<S<u64>>(S<u64>) -> S<u64> + 349..355 'set(S)': S<u64> + 353..354 'S': S<u64> + 362..366 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64 + 362..374 'get2(set(S))': u64 + 367..370 'set': fn set<S<u64>>(S<u64>) -> S<u64> + 367..373 'set(S)': S<u64> + 371..372 'S': S<u64> + 380..384 'get2': fn get2<str, S<str>>(S<str>) -> str + 380..394 'get2(S::<str>)': str + 385..393 'S::<str>': S<str> + "#]], + ); +} + +#[test] +fn impl_trait_assoc_binding_projection_bug() { + check_types( + r#" +//- minicore: iterator +pub trait Language { + type Kind; +} +pub enum RustLanguage {} +impl Language for RustLanguage { + type Kind = SyntaxKind; +} +struct SyntaxNode<L> {} +fn foo() -> impl Iterator<Item = SyntaxNode<RustLanguage>> {} + +trait Clone { + fn clone(&self) -> Self; +} + +fn api_walkthrough() { + for node in foo() { + node.clone(); + } //^^^^^^^^^^^^ {unknown} +} +"#, + ); +} + +#[test] +fn projection_eq_within_chalk() { + check_infer( + r#" +trait Trait1 { + type Type; +} +trait Trait2<T> { + fn foo(self) -> T; +} +impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {} + +fn test<T: Trait1<Type = u32>>(x: T) { + x.foo(); +}"#, + expect![[r#" + 61..65 'self': Self + 163..164 'x': T + 169..185 '{ ...o(); }': () + 175..176 'x': T + 175..182 'x.foo()': u32 + "#]], + ); +} + +#[test] +fn where_clause_trait_in_scope_for_method_resolution() { + check_types( + r#" +mod foo { + trait Trait { + fn foo(&self) -> u32 { 0 } + } +} + +fn test<T: foo::Trait>(x: T) { + x.foo(); +} //^^^^^^^ u32 +"#, + ); +} + +#[test] +fn super_trait_method_resolution() { + check_infer( + r#" +mod foo { + trait SuperTrait { + fn foo(&self) -> u32 {} + } +} +trait Trait1: foo::SuperTrait {} +trait Trait2 where Self: foo::SuperTrait {} + +fn test<T: Trait1, U: Trait2>(x: T, y: U) { + x.foo(); + y.foo(); +}"#, + expect![[r#" + 49..53 'self': &Self + 62..64 '{}': u32 + 181..182 'x': T + 187..188 'y': U + 193..222 '{ ...o(); }': () + 199..200 'x': T + 199..206 'x.foo()': u32 + 212..213 'y': U + 212..219 'y.foo()': u32 + "#]], + ); +} + +#[test] +fn super_trait_impl_trait_method_resolution() { + check_infer( + r#" +//- minicore: sized +mod foo { + trait SuperTrait { + fn foo(&self) -> u32 {} + } +} +trait Trait1: foo::SuperTrait {} + +fn test(x: &impl Trait1) { + x.foo(); +}"#, + expect![[r#" + 49..53 'self': &Self + 62..64 '{}': u32 + 115..116 'x': &impl Trait1 + 132..148 '{ ...o(); }': () + 138..139 'x': &impl Trait1 + 138..145 'x.foo()': u32 + "#]], + ); +} + +#[test] +fn super_trait_cycle() { + // This just needs to not crash + check_infer( + r#" + trait A: B {} + trait B: A {} + + fn test<T: A>(x: T) { + x.foo(); + } + "#, + expect![[r#" + 43..44 'x': T + 49..65 '{ ...o(); }': () + 55..56 'x': T + 55..62 'x.foo()': {unknown} + "#]], + ); +} + +#[test] +fn super_trait_assoc_type_bounds() { + check_infer( + r#" +trait SuperTrait { type Type; } +trait Trait where Self: SuperTrait {} + +fn get2<U, T: Trait<Type = U>>(t: T) -> U {} +fn set<T: Trait<Type = u64>>(t: T) -> T {t} + +struct S<T>; +impl<T> SuperTrait for S<T> { type Type = T; } +impl<T> Trait for S<T> {} + +fn test() { + get2(set(S)); +}"#, + expect![[r#" + 102..103 't': T + 113..115 '{}': U + 145..146 't': T + 156..159 '{t}': T + 157..158 't': T + 258..279 '{ ...S)); }': () + 264..268 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64 + 264..276 'get2(set(S))': u64 + 269..272 'set': fn set<S<u64>>(S<u64>) -> S<u64> + 269..275 'set(S)': S<u64> + 273..274 'S': S<u64> + "#]], + ); +} + +#[test] +fn fn_trait() { + check_infer_with_mismatches( + r#" +trait FnOnce<Args> { + type Output; + + fn call_once(self, args: Args) -> <Self as FnOnce<Args>>::Output; +} + +fn test<F: FnOnce(u32, u64) -> u128>(f: F) { + f.call_once((1, 2)); +}"#, + expect![[r#" + 56..60 'self': Self + 62..66 'args': Args + 149..150 'f': F + 155..183 '{ ...2)); }': () + 161..162 'f': F + 161..180 'f.call...1, 2))': u128 + 173..179 '(1, 2)': (u32, u64) + 174..175 '1': u32 + 177..178 '2': u64 + "#]], + ); +} + +#[test] +fn fn_ptr_and_item() { + check_infer_with_mismatches( + r#" +#[lang="fn_once"] +trait FnOnce<Args> { + type Output; + + fn call_once(self, args: Args) -> Self::Output; +} + +trait Foo<T> { + fn foo(&self) -> T; +} + +struct Bar<T>(T); + +impl<A1, R, F: FnOnce(A1) -> R> Foo<(A1, R)> for Bar<F> { + fn foo(&self) -> (A1, R) { loop {} } +} + +enum Opt<T> { None, Some(T) } +impl<T> Opt<T> { + fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Opt<U> { loop {} } +} + +fn test() { + let bar: Bar<fn(u8) -> u32>; + bar.foo(); + + let opt: Opt<u8>; + let f: fn(u8) -> u32; + opt.map(f); +}"#, + expect![[r#" + 74..78 'self': Self + 80..84 'args': Args + 139..143 'self': &Self + 243..247 'self': &Bar<F> + 260..271 '{ loop {} }': (A1, R) + 262..269 'loop {}': ! + 267..269 '{}': () + 355..359 'self': Opt<T> + 361..362 'f': F + 377..388 '{ loop {} }': Opt<U> + 379..386 'loop {}': ! + 384..386 '{}': () + 402..518 '{ ...(f); }': () + 412..415 'bar': Bar<fn(u8) -> u32> + 441..444 'bar': Bar<fn(u8) -> u32> + 441..450 'bar.foo()': (u8, u32) + 461..464 'opt': Opt<u8> + 483..484 'f': fn(u8) -> u32 + 505..508 'opt': Opt<u8> + 505..515 'opt.map(f)': Opt<u32> + 513..514 'f': fn(u8) -> u32 + "#]], + ); +} + +#[test] +fn fn_trait_deref_with_ty_default() { + check_infer( + r#" +//- minicore: deref, fn +struct Foo; + +impl Foo { + fn foo(&self) -> usize {} +} + +struct Lazy<T, F = fn() -> T>(F); + +impl<T, F> Lazy<T, F> { + pub fn new(f: F) -> Lazy<T, F> {} +} + +impl<T, F: FnOnce() -> T> core::ops::Deref for Lazy<T, F> { + type Target = T; +} + +fn test() { + let lazy1: Lazy<Foo, _> = Lazy::new(|| Foo); + let r1 = lazy1.foo(); + + fn make_foo_fn() -> Foo {} + let make_foo_fn_ptr: fn() -> Foo = make_foo_fn; + let lazy2: Lazy<Foo, _> = Lazy::new(make_foo_fn_ptr); + let r2 = lazy2.foo(); +}"#, + expect![[r#" + 36..40 'self': &Foo + 51..53 '{}': usize + 131..132 'f': F + 151..153 '{}': Lazy<T, F> + 251..497 '{ ...o(); }': () + 261..266 'lazy1': Lazy<Foo, || -> Foo> + 283..292 'Lazy::new': fn new<Foo, || -> Foo>(|| -> Foo) -> Lazy<Foo, || -> Foo> + 283..300 'Lazy::...| Foo)': Lazy<Foo, || -> Foo> + 293..299 '|| Foo': || -> Foo + 296..299 'Foo': Foo + 310..312 'r1': usize + 315..320 'lazy1': Lazy<Foo, || -> Foo> + 315..326 'lazy1.foo()': usize + 368..383 'make_foo_fn_ptr': fn() -> Foo + 399..410 'make_foo_fn': fn make_foo_fn() -> Foo + 420..425 'lazy2': Lazy<Foo, fn() -> Foo> + 442..451 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo> + 442..468 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo> + 452..467 'make_foo_fn_ptr': fn() -> Foo + 478..480 'r2': usize + 483..488 'lazy2': Lazy<Foo, fn() -> Foo> + 483..494 'lazy2.foo()': usize + 357..359 '{}': Foo + "#]], + ); +} + +#[test] +fn closure_1() { + check_infer_with_mismatches( + r#" +//- minicore: fn +enum Option<T> { Some(T), None } +impl<T> Option<T> { + fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> { loop {} } +} + +fn test() { + let x = Option::Some(1u32); + x.map(|v| v + 1); + x.map(|_v| 1u64); + let y: Option<i64> = x.map(|_v| 1); +}"#, + expect![[r#" + 86..90 'self': Option<T> + 92..93 'f': F + 111..122 '{ loop {} }': Option<U> + 113..120 'loop {}': ! + 118..120 '{}': () + 136..255 '{ ... 1); }': () + 146..147 'x': Option<u32> + 150..162 'Option::Some': Some<u32>(u32) -> Option<u32> + 150..168 'Option...(1u32)': Option<u32> + 163..167 '1u32': u32 + 174..175 'x': Option<u32> + 174..190 'x.map(...v + 1)': Option<u32> + 180..189 '|v| v + 1': |u32| -> u32 + 181..182 'v': u32 + 184..185 'v': u32 + 184..189 'v + 1': u32 + 188..189 '1': u32 + 196..197 'x': Option<u32> + 196..212 'x.map(... 1u64)': Option<u64> + 202..211 '|_v| 1u64': |u32| -> u64 + 203..205 '_v': u32 + 207..211 '1u64': u64 + 222..223 'y': Option<i64> + 239..240 'x': Option<u32> + 239..252 'x.map(|_v| 1)': Option<i64> + 245..251 '|_v| 1': |u32| -> i64 + 246..248 '_v': u32 + 250..251 '1': i64 + "#]], + ); +} + +#[test] +fn closure_2() { + check_types( + r#" +//- minicore: add, fn + +impl core::ops::Add for u64 { + type Output = Self; + fn add(self, rhs: u64) -> Self::Output {0} +} + +impl core::ops::Add for u128 { + type Output = Self; + fn add(self, rhs: u128) -> Self::Output {0} +} + +fn test<F: FnOnce(u32) -> u64>(f: F) { + f(1); + // ^ u32 + //^^^^ u64 + let g = |v| v + 1; + //^^^^^ u64 + //^^^^^^^^^ |u64| -> u64 + g(1u64); + //^^^^^^^ u64 + let h = |v| 1u128 + v; + //^^^^^^^^^^^^^ |u128| -> u128 +}"#, + ); +} + +#[test] +fn closure_as_argument_inference_order() { + check_infer_with_mismatches( + r#" +//- minicore: fn +fn foo1<T, U, F: FnOnce(T) -> U>(x: T, f: F) -> U { loop {} } +fn foo2<T, U, F: FnOnce(T) -> U>(f: F, x: T) -> U { loop {} } + +struct S; +impl S { + fn method(self) -> u64; + + fn foo1<T, U, F: FnOnce(T) -> U>(self, x: T, f: F) -> U { loop {} } + fn foo2<T, U, F: FnOnce(T) -> U>(self, f: F, x: T) -> U { loop {} } +} + +fn test() { + let x1 = foo1(S, |s| s.method()); + let x2 = foo2(|s| s.method(), S); + let x3 = S.foo1(S, |s| s.method()); + let x4 = S.foo2(|s| s.method(), S); +}"#, + expect![[r#" + 33..34 'x': T + 39..40 'f': F + 50..61 '{ loop {} }': U + 52..59 'loop {}': ! + 57..59 '{}': () + 95..96 'f': F + 101..102 'x': T + 112..123 '{ loop {} }': U + 114..121 'loop {}': ! + 119..121 '{}': () + 158..162 'self': S + 210..214 'self': S + 216..217 'x': T + 222..223 'f': F + 233..244 '{ loop {} }': U + 235..242 'loop {}': ! + 240..242 '{}': () + 282..286 'self': S + 288..289 'f': F + 294..295 'x': T + 305..316 '{ loop {} }': U + 307..314 'loop {}': ! + 312..314 '{}': () + 330..489 '{ ... S); }': () + 340..342 'x1': u64 + 345..349 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64 + 345..368 'foo1(S...hod())': u64 + 350..351 'S': S + 353..367 '|s| s.method()': |S| -> u64 + 354..355 's': S + 357..358 's': S + 357..367 's.method()': u64 + 378..380 'x2': u64 + 383..387 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64 + 383..406 'foo2(|...(), S)': u64 + 388..402 '|s| s.method()': |S| -> u64 + 389..390 's': S + 392..393 's': S + 392..402 's.method()': u64 + 404..405 'S': S + 416..418 'x3': u64 + 421..422 'S': S + 421..446 'S.foo1...hod())': u64 + 428..429 'S': S + 431..445 '|s| s.method()': |S| -> u64 + 432..433 's': S + 435..436 's': S + 435..445 's.method()': u64 + 456..458 'x4': u64 + 461..462 'S': S + 461..486 'S.foo2...(), S)': u64 + 468..482 '|s| s.method()': |S| -> u64 + 469..470 's': S + 472..473 's': S + 472..482 's.method()': u64 + 484..485 'S': S + "#]], + ); +} + +#[test] +fn fn_item_fn_trait() { + check_types( + r#" +//- minicore: fn +struct S; + +fn foo() -> S { S } + +fn takes_closure<U, F: FnOnce() -> U>(f: F) -> U { f() } + +fn test() { + takes_closure(foo); +} //^^^^^^^^^^^^^^^^^^ S +"#, + ); +} + +#[test] +fn unselected_projection_in_trait_env_1() { + check_types( + r#" +//- /main.rs +trait Trait { + type Item; +} + +trait Trait2 { + fn foo(&self) -> u32; +} + +fn test<T: Trait>() where T::Item: Trait2 { + let x: T::Item = no_matter; + x.foo(); +} //^^^^^^^ u32 +"#, + ); +} + +#[test] +fn unselected_projection_in_trait_env_2() { + check_types( + r#" +trait Trait<T> { + type Item; +} + +trait Trait2 { + fn foo(&self) -> u32; +} + +fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> { + let x: T::Item = no_matter; + x.foo(); +} //^^^^^^^ u32 +"#, + ); +} + +#[test] +fn unselected_projection_on_impl_self() { + check_infer( + r#" +//- /main.rs +trait Trait { + type Item; + + fn f(&self, x: Self::Item); +} + +struct S; + +impl Trait for S { + type Item = u32; + fn f(&self, x: Self::Item) { let y = x; } +} + +struct S2; + +impl Trait for S2 { + type Item = i32; + fn f(&self, x: <Self>::Item) { let y = x; } +}"#, + expect![[r#" + 40..44 'self': &Self + 46..47 'x': Trait::Item<Self> + 126..130 'self': &S + 132..133 'x': u32 + 147..161 '{ let y = x; }': () + 153..154 'y': u32 + 157..158 'x': u32 + 228..232 'self': &S2 + 234..235 'x': i32 + 251..265 '{ let y = x; }': () + 257..258 'y': i32 + 261..262 'x': i32 + "#]], + ); +} + +#[test] +fn unselected_projection_on_trait_self() { + check_types( + r#" +trait Trait { + type Item; + + fn f(&self) -> Self::Item { loop {} } +} + +struct S; +impl Trait for S { + type Item = u32; +} + +fn test() { + S.f(); +} //^^^^^ u32 +"#, + ); +} + +#[test] +fn unselected_projection_chalk_fold() { + check_types( + r#" +trait Interner {} +trait Fold<I: Interner, TI = I> { + type Result; +} + +struct Ty<I: Interner> {} +impl<I: Interner, TI: Interner> Fold<I, TI> for Ty<I> { + type Result = Ty<TI>; +} + +fn fold<I: Interner, T>(interner: &I, t: T) -> T::Result +where + T: Fold<I, I>, +{ + loop {} +} + +fn foo<I: Interner>(interner: &I, t: Ty<I>) { + fold(interner, t); +} //^^^^^^^^^^^^^^^^^ Ty<I> +"#, + ); +} + +#[test] +fn trait_impl_self_ty() { + check_types( + r#" +trait Trait<T> { + fn foo(&self); +} + +struct S; + +impl Trait<Self> for S {} + +fn test() { + S.foo(); +} //^^^^^^^ () +"#, + ); +} + +#[test] +fn trait_impl_self_ty_cycle() { + check_types( + r#" +trait Trait { + fn foo(&self); +} + +struct S<T>; + +impl Trait for S<Self> {} + +fn test() { + S.foo(); +} //^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn unselected_projection_in_trait_env_cycle_1() { + // This is not a cycle, because the `T: Trait2<T::Item>` bound depends only on the `T: Trait` + // bound, not on itself (since only `Trait` can define `Item`). + check_types( + r#" +trait Trait { + type Item; +} + +trait Trait2<T> {} + +fn test<T: Trait>() where T: Trait2<T::Item> { + let x: T::Item = no_matter; +} //^^^^^^^^^ Trait::Item<T> +"#, + ); +} + +#[test] +fn unselected_projection_in_trait_env_cycle_2() { + // this is a legitimate cycle + check_types( + r#" +//- /main.rs +trait Trait<T> { + type Item; +} + +fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> { + let x: T::Item = no_matter; +} //^^^^^^^^^ {unknown} +"#, + ); +} + +#[test] +fn unselected_projection_in_trait_env_cycle_3() { + // this is a cycle for rustc; we currently accept it + check_types( + r#" +//- /main.rs +trait Trait { + type Item; + type OtherItem; +} + +fn test<T>() where T: Trait<OtherItem = T::Item> { + let x: T::Item = no_matter; +} //^^^^^^^^^ Trait::Item<T> +"#, + ); +} + +#[test] +fn unselected_projection_in_trait_env_no_cycle() { + // this is not a cycle + check_types( + r#" +//- /main.rs +trait Index { + type Output; +} + +type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key; + +pub trait UnificationStoreBase: Index<Output = Key<Self>> { + type Key; + + fn len(&self) -> usize; +} + +pub trait UnificationStoreMut: UnificationStoreBase { + fn push(&mut self, value: Self::Key); +} + +fn test<T>(t: T) where T: UnificationStoreMut { + let x; + t.push(x); + let y: Key<T>; + (x, y); +} //^^^^^^ (UnificationStoreBase::Key<T>, UnificationStoreBase::Key<T>) +"#, + ); +} + +#[test] +fn inline_assoc_type_bounds_1() { + check_types( + r#" +trait Iterator { + type Item; +} +trait OtherTrait<T> { + fn foo(&self) -> T; +} + +// workaround for Chalk assoc type normalization problems +pub struct S<T>; +impl<T: Iterator> Iterator for S<T> { + type Item = <T as Iterator>::Item; +} + +fn test<I: Iterator<Item: OtherTrait<u32>>>() { + let x: <S<I> as Iterator>::Item; + x.foo(); +} //^^^^^^^ u32 +"#, + ); +} + +#[test] +fn inline_assoc_type_bounds_2() { + check_types( + r#" +trait Iterator { + type Item; +} + +fn test<I: Iterator<Item: Iterator<Item = u32>>>() { + let x: <<I as Iterator>::Item as Iterator>::Item; + x; +} //^ u32 +"#, + ); +} + +#[test] +fn proc_macro_server_types() { + check_infer( + r#" +macro_rules! with_api { + ($S:ident, $self:ident, $m:ident) => { + $m! { + TokenStream { + fn new() -> $S::TokenStream; + }, + Group { + }, + } + }; +} +macro_rules! associated_item { + (type TokenStream) => + (type TokenStream: 'static;); + (type Group) => + (type Group: 'static;); + ($($item:tt)*) => ($($item)*;) +} +macro_rules! declare_server_traits { + ($($name:ident { + $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)* + }),* $(,)?) => { + pub trait Types { + $(associated_item!(type $name);)* + } + + $(pub trait $name: Types { + $(associated_item!(fn $method($($arg: $arg_ty),*) $(-> $ret_ty)?);)* + })* + + pub trait Server: Types $(+ $name)* {} + impl<S: Types $(+ $name)*> Server for S {} + } +} + +with_api!(Self, self_, declare_server_traits); +struct G {} +struct T {} +struct RustAnalyzer; +impl Types for RustAnalyzer { + type TokenStream = T; + type Group = G; +} + +fn make<T>() -> T { loop {} } +impl TokenStream for RustAnalyzer { + fn new() -> Self::TokenStream { + let group: Self::Group = make(); + make() + } +}"#, + expect![[r#" + 1075..1086 '{ loop {} }': T + 1077..1084 'loop {}': ! + 1082..1084 '{}': () + 1157..1220 '{ ... }': T + 1171..1176 'group': G + 1192..1196 'make': fn make<G>() -> G + 1192..1198 'make()': G + 1208..1212 'make': fn make<T>() -> T + 1208..1214 'make()': T + "#]], + ); +} + +#[test] +fn unify_impl_trait() { + check_infer_with_mismatches( + r#" +//- minicore: sized +trait Trait<T> {} + +fn foo(x: impl Trait<u32>) { loop {} } +fn bar<T>(x: impl Trait<T>) -> T { loop {} } + +struct S<T>(T); +impl<T> Trait<T> for S<T> {} + +fn default<T>() -> T { loop {} } + +fn test() -> impl Trait<i32> { + let s1 = S(default()); + foo(s1); + let x: i32 = bar(S(default())); + S(default()) +}"#, + expect![[r#" + 26..27 'x': impl Trait<u32> + 46..57 '{ loop {} }': () + 48..55 'loop {}': ! + 53..55 '{}': () + 68..69 'x': impl Trait<T> + 91..102 '{ loop {} }': T + 93..100 'loop {}': ! + 98..100 '{}': () + 171..182 '{ loop {} }': T + 173..180 'loop {}': ! + 178..180 '{}': () + 213..309 '{ ...t()) }': S<i32> + 223..225 's1': S<u32> + 228..229 'S': S<u32>(u32) -> S<u32> + 228..240 'S(default())': S<u32> + 230..237 'default': fn default<u32>() -> u32 + 230..239 'default()': u32 + 246..249 'foo': fn foo(S<u32>) + 246..253 'foo(s1)': () + 250..252 's1': S<u32> + 263..264 'x': i32 + 272..275 'bar': fn bar<i32>(S<i32>) -> i32 + 272..289 'bar(S(...lt()))': i32 + 276..277 'S': S<i32>(i32) -> S<i32> + 276..288 'S(default())': S<i32> + 278..285 'default': fn default<i32>() -> i32 + 278..287 'default()': i32 + 295..296 'S': S<i32>(i32) -> S<i32> + 295..307 'S(default())': S<i32> + 297..304 'default': fn default<i32>() -> i32 + 297..306 'default()': i32 + "#]], + ); +} + +#[test] +fn assoc_types_from_bounds() { + check_infer( + r#" +//- minicore: fn +trait T { + type O; +} + +impl T for () { + type O = (); +} + +fn f<X, F>(_v: F) +where + X: T, + F: FnOnce(&X::O), +{ } + +fn main() { + f::<(), _>(|z| { z; }); +}"#, + expect![[r#" + 72..74 '_v': F + 117..120 '{ }': () + 132..163 '{ ... }); }': () + 138..148 'f::<(), _>': fn f<(), |&()| -> ()>(|&()| -> ()) + 138..160 'f::<()... z; })': () + 149..159 '|z| { z; }': |&()| -> () + 150..151 'z': &() + 153..159 '{ z; }': () + 155..156 'z': &() + "#]], + ); +} + +#[test] +fn associated_type_bound() { + check_types( + r#" +pub trait Trait { + type Item: OtherTrait<u32>; +} +pub trait OtherTrait<T> { + fn foo(&self) -> T; +} + +// this is just a workaround for chalk#234 +pub struct S<T>; +impl<T: Trait> Trait for S<T> { + type Item = <T as Trait>::Item; +} + +fn test<T: Trait>() { + let y: <S<T> as Trait>::Item = no_matter; + y.foo(); +} //^^^^^^^ u32 +"#, + ); +} + +#[test] +fn dyn_trait_through_chalk() { + check_types( + r#" +//- minicore: deref +struct Box<T: ?Sized> {} +impl<T: ?Sized> core::ops::Deref for Box<T> { + type Target = T; +} +trait Trait { + fn foo(&self); +} + +fn test(x: Box<dyn Trait>) { + x.foo(); +} //^^^^^^^ () +"#, + ); +} + +#[test] +fn string_to_owned() { + check_types( + r#" +struct String {} +pub trait ToOwned { + type Owned; + fn to_owned(&self) -> Self::Owned; +} +impl ToOwned for str { + type Owned = String; +} +fn test() { + "foo".to_owned(); +} //^^^^^^^^^^^^^^^^ String +"#, + ); +} + +#[test] +fn iterator_chain() { + check_infer_with_mismatches( + r#" +//- minicore: fn, option +pub trait Iterator { + type Item; + + fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> + where + F: FnMut(Self::Item) -> Option<B>, + { loop {} } + + fn for_each<F>(self, f: F) + where + F: FnMut(Self::Item), + { loop {} } +} + +pub trait IntoIterator { + type Item; + type IntoIter: Iterator<Item = Self::Item>; + fn into_iter(self) -> Self::IntoIter; +} + +pub struct FilterMap<I, F> { } +impl<B, I: Iterator, F> Iterator for FilterMap<I, F> +where + F: FnMut(I::Item) -> Option<B>, +{ + type Item = B; +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<I: Iterator> IntoIterator for I { + type Item = I::Item; + type IntoIter = I; + + fn into_iter(self) -> I { + self + } +} + +struct Vec<T> {} +impl<T> Vec<T> { + fn new() -> Self { loop {} } +} + +impl<T> IntoIterator for Vec<T> { + type Item = T; + type IntoIter = IntoIter<T>; +} + +pub struct IntoIter<T> { } +impl<T> Iterator for IntoIter<T> { + type Item = T; +} + +fn main() { + Vec::<i32>::new().into_iter() + .filter_map(|x| if x > 0 { Some(x as u32) } else { None }) + .for_each(|y| { y; }); +}"#, + expect![[r#" + 61..65 'self': Self + 67..68 'f': F + 152..163 '{ loop {} }': FilterMap<Self, F> + 154..161 'loop {}': ! + 159..161 '{}': () + 184..188 'self': Self + 190..191 'f': F + 240..251 '{ loop {} }': () + 242..249 'loop {}': ! + 247..249 '{}': () + 360..364 'self': Self + 689..693 'self': I + 700..720 '{ ... }': I + 710..714 'self': I + 779..790 '{ loop {} }': Vec<T> + 781..788 'loop {}': ! + 786..788 '{}': () + 977..1104 '{ ... }); }': () + 983..998 'Vec::<i32>::new': fn new<i32>() -> Vec<i32> + 983..1000 'Vec::<...:new()': Vec<i32> + 983..1012 'Vec::<...iter()': IntoIter<i32> + 983..1075 'Vec::<...one })': FilterMap<IntoIter<i32>, |i32| -> Option<u32>> + 983..1101 'Vec::<... y; })': () + 1029..1074 '|x| if...None }': |i32| -> Option<u32> + 1030..1031 'x': i32 + 1033..1074 'if x >...None }': Option<u32> + 1036..1037 'x': i32 + 1036..1041 'x > 0': bool + 1040..1041 '0': i32 + 1042..1060 '{ Some...u32) }': Option<u32> + 1044..1048 'Some': Some<u32>(u32) -> Option<u32> + 1044..1058 'Some(x as u32)': Option<u32> + 1049..1050 'x': i32 + 1049..1057 'x as u32': u32 + 1066..1074 '{ None }': Option<u32> + 1068..1072 'None': Option<u32> + 1090..1100 '|y| { y; }': |u32| -> () + 1091..1092 'y': u32 + 1094..1100 '{ y; }': () + 1096..1097 'y': u32 + "#]], + ); +} + +#[test] +fn nested_assoc() { + check_types( + r#" +struct Bar; +struct Foo; + +trait A { + type OutputA; +} + +impl A for Bar { + type OutputA = Foo; +} + +trait B { + type Output; + fn foo() -> Self::Output; +} + +impl<T:A> B for T { + type Output = T::OutputA; + fn foo() -> Self::Output { loop {} } +} + +fn main() { + Bar::foo(); +} //^^^^^^^^^^ Foo +"#, + ); +} + +#[test] +fn trait_object_no_coercion() { + check_infer_with_mismatches( + r#" +trait Foo {} + +fn foo(x: &dyn Foo) {} + +fn test(x: &dyn Foo) { + foo(x); +}"#, + expect![[r#" + 21..22 'x': &dyn Foo + 34..36 '{}': () + 46..47 'x': &dyn Foo + 59..74 '{ foo(x); }': () + 65..68 'foo': fn foo(&dyn Foo) + 65..71 'foo(x)': () + 69..70 'x': &dyn Foo + "#]], + ); +} + +#[test] +fn builtin_copy() { + check_infer_with_mismatches( + r#" +//- minicore: copy +struct IsCopy; +impl Copy for IsCopy {} +struct NotCopy; + +trait Test { fn test(&self) -> bool; } +impl<T: Copy> Test for T {} + +fn test() { + IsCopy.test(); + NotCopy.test(); + (IsCopy, IsCopy).test(); + (IsCopy, NotCopy).test(); +}"#, + expect![[r#" + 78..82 'self': &Self + 134..235 '{ ...t(); }': () + 140..146 'IsCopy': IsCopy + 140..153 'IsCopy.test()': bool + 159..166 'NotCopy': NotCopy + 159..173 'NotCopy.test()': {unknown} + 179..195 '(IsCop...sCopy)': (IsCopy, IsCopy) + 179..202 '(IsCop...test()': bool + 180..186 'IsCopy': IsCopy + 188..194 'IsCopy': IsCopy + 208..225 '(IsCop...tCopy)': (IsCopy, NotCopy) + 208..232 '(IsCop...test()': {unknown} + 209..215 'IsCopy': IsCopy + 217..224 'NotCopy': NotCopy + "#]], + ); +} + +#[test] +fn builtin_fn_def_copy() { + check_infer_with_mismatches( + r#" +//- minicore: copy +fn foo() {} +fn bar<T: Copy>(T) -> T {} +struct Struct(usize); +enum Enum { Variant(usize) } + +trait Test { fn test(&self) -> bool; } +impl<T: Copy> Test for T {} + +fn test() { + foo.test(); + bar.test(); + Struct.test(); + Enum::Variant.test(); +}"#, + expect![[r#" + 9..11 '{}': () + 28..29 'T': {unknown} + 36..38 '{}': T + 36..38: expected T, got () + 113..117 'self': &Self + 169..249 '{ ...t(); }': () + 175..178 'foo': fn foo() + 175..185 'foo.test()': bool + 191..194 'bar': fn bar<{unknown}>({unknown}) -> {unknown} + 191..201 'bar.test()': bool + 207..213 'Struct': Struct(usize) -> Struct + 207..220 'Struct.test()': bool + 226..239 'Enum::Variant': Variant(usize) -> Enum + 226..246 'Enum::...test()': bool + "#]], + ); +} + +#[test] +fn builtin_fn_ptr_copy() { + check_infer_with_mismatches( + r#" +//- minicore: copy +trait Test { fn test(&self) -> bool; } +impl<T: Copy> Test for T {} + +fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) { + f1.test(); + f2.test(); + f3.test(); +}"#, + expect![[r#" + 22..26 'self': &Self + 76..78 'f1': fn() + 86..88 'f2': fn(usize) -> u8 + 107..109 'f3': fn(u8, u8) -> &u8 + 130..178 '{ ...t(); }': () + 136..138 'f1': fn() + 136..145 'f1.test()': bool + 151..153 'f2': fn(usize) -> u8 + 151..160 'f2.test()': bool + 166..168 'f3': fn(u8, u8) -> &u8 + 166..175 'f3.test()': bool + "#]], + ); +} + +#[test] +fn builtin_sized() { + check_infer_with_mismatches( + r#" +//- minicore: sized +trait Test { fn test(&self) -> bool; } +impl<T: Sized> Test for T {} + +fn test() { + 1u8.test(); + (*"foo").test(); // not Sized + (1u8, 1u8).test(); + (1u8, *"foo").test(); // not Sized +}"#, + expect![[r#" + 22..26 'self': &Self + 79..194 '{ ...ized }': () + 85..88 '1u8': u8 + 85..95 '1u8.test()': bool + 101..116 '(*"foo").test()': {unknown} + 102..108 '*"foo"': str + 103..108 '"foo"': &str + 135..145 '(1u8, 1u8)': (u8, u8) + 135..152 '(1u8, ...test()': bool + 136..139 '1u8': u8 + 141..144 '1u8': u8 + 158..171 '(1u8, *"foo")': (u8, str) + 158..178 '(1u8, ...test()': {unknown} + 159..162 '1u8': u8 + 164..170 '*"foo"': str + 165..170 '"foo"': &str + "#]], + ); +} + +#[test] +fn integer_range_iterate() { + check_types( + r#" +//- /main.rs crate:main deps:core +fn test() { + for x in 0..100 { x; } +} //^ i32 + +//- /core.rs crate:core +pub mod ops { + pub struct Range<Idx> { + pub start: Idx, + pub end: Idx, + } +} + +pub mod iter { + pub trait Iterator { + type Item; + } + + pub trait IntoIterator { + type Item; + type IntoIter: Iterator<Item = Self::Item>; + } + + impl<T> IntoIterator for T where T: Iterator { + type Item = <T as Iterator>::Item; + type IntoIter = Self; + } +} + +trait Step {} +impl Step for i32 {} +impl Step for i64 {} + +impl<A: Step> iter::Iterator for ops::Range<A> { + type Item = A; +} +"#, + ); +} + +#[test] +fn infer_closure_arg() { + check_infer( + r#" +//- /lib.rs + +enum Option<T> { + None, + Some(T) +} + +fn foo() { + let s = Option::None; + let f = |x: Option<i32>| {}; + (&f)(s) +}"#, + expect![[r#" + 52..126 '{ ...)(s) }': () + 62..63 's': Option<i32> + 66..78 'Option::None': Option<i32> + 88..89 'f': |Option<i32>| -> () + 92..111 '|x: Op...2>| {}': |Option<i32>| -> () + 93..94 'x': Option<i32> + 109..111 '{}': () + 117..124 '(&f)(s)': () + 118..120 '&f': &|Option<i32>| -> () + 119..120 'f': |Option<i32>| -> () + 122..123 's': Option<i32> + "#]], + ); +} + +#[test] +fn dyn_fn_param_informs_call_site_closure_signature() { + cov_mark::check!(dyn_fn_param_informs_call_site_closure_signature); + check_types( + r#" +//- minicore: fn, coerce_unsized +struct S; +impl S { + fn inherent(&self) -> u8 { 0 } +} +fn take_dyn_fn(f: &dyn Fn(S)) {} + +fn f() { + take_dyn_fn(&|x| { x.inherent(); }); + //^^^^^^^^^^^^ u8 +} + "#, + ); +} + +#[test] +fn infer_fn_trait_arg() { + check_infer_with_mismatches( + r#" +//- minicore: fn, option +fn foo<F, T>(f: F) -> T +where + F: Fn(Option<i32>) -> T, +{ + let s = None; + f(s) +} +"#, + expect![[r#" + 13..14 'f': F + 59..89 '{ ...f(s) }': T + 69..70 's': Option<i32> + 73..77 'None': Option<i32> + 83..84 'f': F + 83..87 'f(s)': T + 85..86 's': Option<i32> + "#]], + ); +} + +#[test] +fn infer_box_fn_arg() { + // The type mismatch is because we don't define Unsize and CoerceUnsized + check_infer_with_mismatches( + r#" +//- minicore: fn, deref, option +#[lang = "owned_box"] +pub struct Box<T: ?Sized> { + inner: *mut T, +} + +impl<T: ?Sized> core::ops::Deref for Box<T> { + type Target = T; + + fn deref(&self) -> &T { + &self.inner + } +} + +fn foo() { + let s = None; + let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {}); + f(&s); +}"#, + expect![[r#" + 154..158 'self': &Box<T> + 166..193 '{ ... }': &T + 176..187 '&self.inner': &*mut T + 177..181 'self': &Box<T> + 177..187 'self.inner': *mut T + 206..296 '{ ...&s); }': () + 216..217 's': Option<i32> + 220..224 'None': Option<i32> + 234..235 'f': Box<dyn FnOnce(&Option<i32>)> + 269..282 'box (|ps| {})': Box<|&Option<i32>| -> ()> + 274..281 '|ps| {}': |&Option<i32>| -> () + 275..277 'ps': &Option<i32> + 279..281 '{}': () + 288..289 'f': Box<dyn FnOnce(&Option<i32>)> + 288..293 'f(&s)': () + 290..292 '&s': &Option<i32> + 291..292 's': Option<i32> + 269..282: expected Box<dyn FnOnce(&Option<i32>)>, got Box<|&Option<i32>| -> ()> + "#]], + ); +} + +#[test] +fn infer_dyn_fn_output() { + check_types( + r#" +//- minicore: fn +fn foo() { + let f: &dyn Fn() -> i32; + f(); + //^^^ i32 +}"#, + ); +} + +#[test] +fn infer_dyn_fn_once_output() { + check_types( + r#" +//- minicore: fn +fn foo() { + let f: dyn FnOnce() -> i32; + f(); + //^^^ i32 +}"#, + ); +} + +#[test] +fn variable_kinds_1() { + check_types( + r#" +trait Trait<T> { fn get(self, t: T) -> T; } +struct S; +impl Trait<u128> for S {} +impl Trait<f32> for S {} +fn test() { + S.get(1); + //^^^^^^^^ u128 + S.get(1.); + //^^^^^^^^^ f32 +} + "#, + ); +} + +#[test] +fn variable_kinds_2() { + check_types( + r#" +trait Trait { fn get(self) -> Self; } +impl Trait for u128 {} +impl Trait for f32 {} +fn test() { + 1.get(); + //^^^^^^^ u128 + (1.).get(); + //^^^^^^^^^^ f32 +} + "#, + ); +} + +#[test] +fn underscore_import() { + check_types( + r#" +mod tr { + pub trait Tr { + fn method(&self) -> u8 { 0 } + } +} + +struct Tr; +impl crate::tr::Tr for Tr {} + +use crate::tr::Tr as _; +fn test() { + Tr.method(); + //^^^^^^^^^^^ u8 +} + "#, + ); +} + +#[test] +fn inner_use() { + check_types( + r#" +mod m { + pub trait Tr { + fn method(&self) -> u8 { 0 } + } + + impl Tr for () {} +} + +fn f() { + use m::Tr; + + ().method(); + //^^^^^^^^^^^ u8 +} + "#, + ); +} + +#[test] +fn trait_in_scope_with_inner_item() { + check_infer( + r#" +mod m { + pub trait Tr { + fn method(&self) -> u8 { 0 } + } + + impl Tr for () {} +} + +use m::Tr; + +fn f() { + fn inner() { + ().method(); + //^^^^^^^^^^^ u8 + } +}"#, + expect![[r#" + 46..50 'self': &Self + 58..63 '{ 0 }': u8 + 60..61 '0': u8 + 115..185 '{ ... } }': () + 132..183 '{ ... }': () + 142..144 '()': () + 142..153 '().method()': u8 + "#]], + ); +} + +#[test] +fn inner_use_in_block() { + check_types( + r#" +mod m { + pub trait Tr { + fn method(&self) -> u8 { 0 } + } + + impl Tr for () {} +} + +fn f() { + { + use m::Tr; + + ().method(); + //^^^^^^^^^^^ u8 + } + + { + ().method(); + //^^^^^^^^^^^ {unknown} + } + + ().method(); + //^^^^^^^^^^^ {unknown} +} + "#, + ); +} + +#[test] +fn nested_inner_function_calling_self() { + check_infer( + r#" +struct S; +fn f() { + fn inner() -> S { + let s = inner(); + } +}"#, + expect![[r#" + 17..73 '{ ... } }': () + 39..71 '{ ... }': S + 53..54 's': S + 57..62 'inner': fn inner() -> S + 57..64 'inner()': S + "#]], + ) +} + +#[test] +fn infer_default_trait_type_parameter() { + check_infer( + r#" +struct A; + +trait Op<RHS=Self> { + type Output; + + fn do_op(self, rhs: RHS) -> Self::Output; +} + +impl Op for A { + type Output = bool; + + fn do_op(self, rhs: Self) -> Self::Output { + true + } +} + +fn test() { + let x = A; + let y = A; + let r = x.do_op(y); +}"#, + expect![[r#" + 63..67 'self': Self + 69..72 'rhs': RHS + 153..157 'self': A + 159..162 'rhs': A + 186..206 '{ ... }': bool + 196..200 'true': bool + 220..277 '{ ...(y); }': () + 230..231 'x': A + 234..235 'A': A + 245..246 'y': A + 249..250 'A': A + 260..261 'r': bool + 264..265 'x': A + 264..274 'x.do_op(y)': bool + 272..273 'y': A + "#]], + ) +} + +#[test] +fn qualified_path_as_qualified_trait() { + check_infer( + r#" +mod foo { + + pub trait Foo { + type Target; + } + pub trait Bar { + type Output; + fn boo() -> Self::Output { + loop {} + } + } +} + +struct F; +impl foo::Foo for F { + type Target = (); +} +impl foo::Bar for F { + type Output = <F as foo::Foo>::Target; +} + +fn foo() { + use foo::Bar; + let x = <F as Bar>::boo(); +}"#, + expect![[r#" + 132..163 '{ ... }': Bar::Output<Self> + 146..153 'loop {}': ! + 151..153 '{}': () + 306..358 '{ ...o(); }': () + 334..335 'x': () + 338..353 '<F as Bar>::boo': fn boo<F>() -> <F as Bar>::Output + 338..355 '<F as ...:boo()': () + "#]], + ); +} + +#[test] +fn renamed_extern_crate_in_block() { + check_types( + r#" +//- /lib.rs crate:lib deps:serde +use serde::Deserialize; + +struct Foo {} + +const _ : () = { + extern crate serde as _serde; + impl _serde::Deserialize for Foo { + fn deserialize() -> u8 { 0 } + } +}; + +fn foo() { + Foo::deserialize(); + //^^^^^^^^^^^^^^^^^^ u8 +} + +//- /serde.rs crate:serde + +pub trait Deserialize { + fn deserialize() -> u8; +}"#, + ); +} + +#[test] +fn bin_op_with_rhs_is_self_for_assoc_bound() { + check_no_mismatches( + r#"//- minicore: eq + fn repro<T>(t: T) -> bool +where + T: Request, + T::Output: Convertable, +{ + let a = execute(&t).convert(); + let b = execute(&t).convert(); + a.eq(&b); + let a = execute(&t).convert2(); + let b = execute(&t).convert2(); + a.eq(&b) +} +fn execute<T>(t: &T) -> T::Output +where + T: Request, +{ + <T as Request>::output() +} +trait Convertable { + type TraitSelf: PartialEq<Self::TraitSelf>; + type AssocAsDefaultSelf: PartialEq; + fn convert(self) -> Self::AssocAsDefaultSelf; + fn convert2(self) -> Self::TraitSelf; +} +trait Request { + type Output; + fn output() -> Self::Output; +} + "#, + ); +} + +#[test] +fn bin_op_adt_with_rhs_primitive() { + check_infer_with_mismatches( + r#" +#[lang = "add"] +pub trait Add<Rhs = Self> { + type Output; + fn add(self, rhs: Rhs) -> Self::Output; +} + +struct Wrapper(u32); +impl Add<u32> for Wrapper { + type Output = Self; + fn add(self, rhs: u32) -> Wrapper { + Wrapper(rhs) + } +} +fn main(){ + let wrapped = Wrapper(10); + let num: u32 = 2; + let res = wrapped + num; + +}"#, + expect![[r#" + 72..76 'self': Self + 78..81 'rhs': Rhs + 192..196 'self': Wrapper + 198..201 'rhs': u32 + 219..247 '{ ... }': Wrapper + 229..236 'Wrapper': Wrapper(u32) -> Wrapper + 229..241 'Wrapper(rhs)': Wrapper + 237..240 'rhs': u32 + 259..345 '{ ...um; }': () + 269..276 'wrapped': Wrapper + 279..286 'Wrapper': Wrapper(u32) -> Wrapper + 279..290 'Wrapper(10)': Wrapper + 287..289 '10': u32 + 300..303 'num': u32 + 311..312 '2': u32 + 322..325 'res': Wrapper + 328..335 'wrapped': Wrapper + 328..341 'wrapped + num': Wrapper + 338..341 'num': u32 + "#]], + ) +} + +#[test] +fn array_length() { + check_infer( + r#" +trait T { + type Output; + fn do_thing(&self) -> Self::Output; +} + +impl T for [u8; 4] { + type Output = usize; + fn do_thing(&self) -> Self::Output { + 2 + } +} + +impl T for [u8; 2] { + type Output = u8; + fn do_thing(&self) -> Self::Output { + 2 + } +} + +fn main() { + let v = [0u8; 2]; + let v2 = v.do_thing(); + let v3 = [0u8; 4]; + let v4 = v3.do_thing(); +} +"#, + expect![[r#" + 44..48 'self': &Self + 133..137 'self': &[u8; 4] + 155..172 '{ ... }': usize + 165..166 '2': usize + 236..240 'self': &[u8; 2] + 258..275 '{ ... }': u8 + 268..269 '2': u8 + 289..392 '{ ...g(); }': () + 299..300 'v': [u8; 2] + 303..311 '[0u8; 2]': [u8; 2] + 304..307 '0u8': u8 + 309..310 '2': usize + 321..323 'v2': u8 + 326..327 'v': [u8; 2] + 326..338 'v.do_thing()': u8 + 348..350 'v3': [u8; 4] + 353..361 '[0u8; 4]': [u8; 4] + 354..357 '0u8': u8 + 359..360 '4': usize + 371..373 'v4': usize + 376..378 'v3': [u8; 4] + 376..389 'v3.do_thing()': usize + "#]], + ) +} + +#[test] +fn const_generics() { + check_infer( + r#" +trait T { + type Output; + fn do_thing(&self) -> Self::Output; +} + +impl<const L: usize> T for [u8; L] { + type Output = [u8; L]; + fn do_thing(&self) -> Self::Output { + *self + } +} + +fn main() { + let v = [0u8; 2]; + let v2 = v.do_thing(); +} +"#, + expect![[r#" + 44..48 'self': &Self + 151..155 'self': &[u8; L] + 173..194 '{ ... }': [u8; L] + 183..188 '*self': [u8; L] + 184..188 'self': &[u8; L] + 208..260 '{ ...g(); }': () + 218..219 'v': [u8; 2] + 222..230 '[0u8; 2]': [u8; 2] + 223..226 '0u8': u8 + 228..229 '2': usize + 240..242 'v2': [u8; 2] + 245..246 'v': [u8; 2] + 245..257 'v.do_thing()': [u8; 2] + "#]], + ) +} + +#[test] +fn fn_returning_unit() { + check_infer_with_mismatches( + r#" +//- minicore: fn +fn test<F: FnOnce()>(f: F) { + let _: () = f(); +}"#, + expect![[r#" + 21..22 'f': F + 27..51 '{ ...f(); }': () + 37..38 '_': () + 45..46 'f': F + 45..48 'f()': () + "#]], + ); +} + +#[test] +fn trait_in_scope_of_trait_impl() { + check_infer( + r#" +mod foo { + pub trait Foo { + fn foo(self); + fn bar(self) -> usize { 0 } + } +} +impl foo::Foo for u32 { + fn foo(self) { + let _x = self.bar(); + } +} + "#, + expect![[r#" + 45..49 'self': Self + 67..71 'self': Self + 82..87 '{ 0 }': usize + 84..85 '0': usize + 131..135 'self': u32 + 137..173 '{ ... }': () + 151..153 '_x': usize + 156..160 'self': u32 + 156..166 'self.bar()': usize + "#]], + ); +} + +#[test] +fn infer_async_ret_type() { + check_types( + r#" +//- minicore: future, result +struct Fooey; + +impl Fooey { + fn collect<B: Convert>(self) -> B { + B::new() + } +} + +trait Convert { + fn new() -> Self; +} +impl Convert for u32 { + fn new() -> Self { 0 } +} + +async fn get_accounts() -> Result<u32, ()> { + let ret = Fooey.collect(); + // ^^^^^^^^^^^^^^^ u32 + Ok(ret) +} +"#, + ); +} + +#[test] +fn local_impl_1() { + check!(block_local_impls); + check_types( + r#" +trait Trait<T> { + fn foo(&self) -> T; +} + +fn test() { + struct S; + impl Trait<u32> for S { + fn foo(&self) -> u32 { 0 } + } + + S.foo(); + // ^^^^^^^ u32 +} +"#, + ); +} + +#[test] +fn local_impl_2() { + check!(block_local_impls); + check_types( + r#" +struct S; + +fn test() { + trait Trait<T> { + fn foo(&self) -> T; + } + impl Trait<u32> for S { + fn foo(&self) -> u32 { 0 } + } + + S.foo(); + // ^^^^^^^ u32 +} +"#, + ); +} + +#[test] +fn local_impl_3() { + check!(block_local_impls); + check_types( + r#" +trait Trait<T> { + fn foo(&self) -> T; +} + +fn test() { + struct S1; + { + struct S2; + + impl Trait<S1> for S2 { + fn foo(&self) -> S1 { S1 } + } + + S2.foo(); + // ^^^^^^^^ S1 + } +} +"#, + ); +} + +#[test] +fn associated_type_sized_bounds() { + check_infer( + r#" +//- minicore: sized +struct Yes; +trait IsSized { const IS_SIZED: Yes; } +impl<T: Sized> IsSized for T { const IS_SIZED: Yes = Yes; } + +trait Foo { + type Explicit: Sized; + type Implicit; + type Relaxed: ?Sized; +} +fn f<F: Foo>() { + F::Explicit::IS_SIZED; + F::Implicit::IS_SIZED; + F::Relaxed::IS_SIZED; +} +"#, + expect![[r#" + 104..107 'Yes': Yes + 212..295 '{ ...ZED; }': () + 218..239 'F::Exp..._SIZED': Yes + 245..266 'F::Imp..._SIZED': Yes + 272..292 'F::Rel..._SIZED': {unknown} + "#]], + ); +} + +#[test] +fn dyn_map() { + check_types( + r#" +pub struct Key<K, V, P = (K, V)> {} + +pub trait Policy { + type K; + type V; +} + +impl<K, V> Policy for (K, V) { + type K = K; + type V = V; +} + +pub struct KeyMap<KEY> {} + +impl<P: Policy> KeyMap<Key<P::K, P::V, P>> { + pub fn get(&self, key: &P::K) -> P::V { + loop {} + } +} + +struct Fn {} +struct FunctionId {} + +fn test() { + let key_map: &KeyMap<Key<Fn, FunctionId>> = loop {}; + let key; + let result = key_map.get(key); + //^^^^^^ FunctionId +} +"#, + ) +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tls.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tls.rs new file mode 100644 index 000000000..547850b02 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/tls.rs @@ -0,0 +1,133 @@ +//! Implementation of Chalk debug helper functions using TLS. +use std::fmt::{self, Display}; + +use itertools::Itertools; + +use crate::{ + chalk_db, db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, mapping::from_chalk, + CallableDefId, Interner, +}; +use hir_def::{AdtId, ItemContainerId, Lookup, TypeAliasId}; + +pub(crate) use unsafe_tls::{set_current_program, with_current_program}; + +pub(crate) struct DebugContext<'a>(&'a dyn HirDatabase); + +impl DebugContext<'_> { + pub(crate) fn debug_struct_id( + &self, + id: chalk_db::AdtId, + f: &mut fmt::Formatter<'_>, + ) -> Result<(), fmt::Error> { + let name = match id.0 { + AdtId::StructId(it) => self.0.struct_data(it).name.clone(), + AdtId::UnionId(it) => self.0.union_data(it).name.clone(), + AdtId::EnumId(it) => self.0.enum_data(it).name.clone(), + }; + name.fmt(f) + } + + pub(crate) fn debug_trait_id( + &self, + id: chalk_db::TraitId, + f: &mut fmt::Formatter<'_>, + ) -> Result<(), fmt::Error> { + let trait_: hir_def::TraitId = from_chalk_trait_id(id); + let trait_data = self.0.trait_data(trait_); + trait_data.name.fmt(f) + } + + pub(crate) fn debug_assoc_type_id( + &self, + id: chalk_db::AssocTypeId, + fmt: &mut fmt::Formatter<'_>, + ) -> Result<(), fmt::Error> { + let type_alias: TypeAliasId = from_assoc_type_id(id); + let type_alias_data = self.0.type_alias_data(type_alias); + let trait_ = match type_alias.lookup(self.0.upcast()).container { + ItemContainerId::TraitId(t) => t, + _ => panic!("associated type not in trait"), + }; + let trait_data = self.0.trait_data(trait_); + write!(fmt, "{}::{}", trait_data.name, type_alias_data.name) + } + + pub(crate) fn debug_projection_ty( + &self, + projection_ty: &chalk_ir::ProjectionTy<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Result<(), fmt::Error> { + let type_alias = from_assoc_type_id(projection_ty.associated_ty_id); + let type_alias_data = self.0.type_alias_data(type_alias); + let trait_ = match type_alias.lookup(self.0.upcast()).container { + ItemContainerId::TraitId(t) => t, + _ => panic!("associated type not in trait"), + }; + let trait_data = self.0.trait_data(trait_); + let params = projection_ty.substitution.as_slice(Interner); + write!(fmt, "<{:?} as {}", ¶ms[0], trait_data.name,)?; + if params.len() > 1 { + write!( + fmt, + "<{}>", + ¶ms[1..].iter().format_with(", ", |x, f| f(&format_args!("{:?}", x))), + )?; + } + write!(fmt, ">::{}", type_alias_data.name) + } + + pub(crate) fn debug_fn_def_id( + &self, + fn_def_id: chalk_ir::FnDefId<Interner>, + fmt: &mut fmt::Formatter<'_>, + ) -> Result<(), fmt::Error> { + let def: CallableDefId = from_chalk(self.0, fn_def_id); + let name = match def { + CallableDefId::FunctionId(ff) => self.0.function_data(ff).name.clone(), + CallableDefId::StructId(s) => self.0.struct_data(s).name.clone(), + CallableDefId::EnumVariantId(e) => { + let enum_data = self.0.enum_data(e.parent); + enum_data.variants[e.local_id].name.clone() + } + }; + match def { + CallableDefId::FunctionId(_) => write!(fmt, "{{fn {}}}", name), + CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => { + write!(fmt, "{{ctor {}}}", name) + } + } + } +} + +mod unsafe_tls { + use super::DebugContext; + use crate::db::HirDatabase; + use scoped_tls::scoped_thread_local; + + scoped_thread_local!(static PROGRAM: DebugContext<'_>); + + pub(crate) fn with_current_program<R>( + op: impl for<'a> FnOnce(Option<&'a DebugContext<'a>>) -> R, + ) -> R { + if PROGRAM.is_set() { + PROGRAM.with(|prog| op(Some(prog))) + } else { + op(None) + } + } + + pub(crate) fn set_current_program<OP, R>(p: &dyn HirDatabase, op: OP) -> R + where + OP: FnOnce() -> R, + { + let ctx = DebugContext(p); + // we're transmuting the lifetime in the DebugContext to static. This is + // fine because we only keep the reference for the lifetime of this + // function, *and* the only way to access the context is through + // `with_current_program`, which hides the lifetime through the `for` + // type. + let static_p: &DebugContext<'static> = + unsafe { std::mem::transmute::<&DebugContext<'_>, &DebugContext<'static>>(&ctx) }; + PROGRAM.set(static_p, op) + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs new file mode 100644 index 000000000..77afeb321 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs @@ -0,0 +1,187 @@ +//! Trait solving using Chalk. + +use std::env::var; + +use chalk_ir::GoalData; +use chalk_recursive::Cache; +use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver}; + +use base_db::CrateId; +use hir_def::{lang_item::LangItemTarget, TraitId}; +use stdx::panic_context; +use syntax::SmolStr; + +use crate::{ + db::HirDatabase, AliasEq, AliasTy, Canonical, DomainGoal, Goal, Guidance, InEnvironment, + Interner, Solution, TraitRefExt, Ty, TyKind, WhereClause, +}; + +/// This controls how much 'time' we give the Chalk solver before giving up. +const CHALK_SOLVER_FUEL: i32 = 100; + +#[derive(Debug, Copy, Clone)] +pub(crate) struct ChalkContext<'a> { + pub(crate) db: &'a dyn HirDatabase, + pub(crate) krate: CrateId, +} + +fn create_chalk_solver() -> chalk_recursive::RecursiveSolver<Interner> { + let overflow_depth = + var("CHALK_OVERFLOW_DEPTH").ok().and_then(|s| s.parse().ok()).unwrap_or(500); + let max_size = var("CHALK_SOLVER_MAX_SIZE").ok().and_then(|s| s.parse().ok()).unwrap_or(150); + chalk_recursive::RecursiveSolver::new(overflow_depth, max_size, Some(Cache::new())) +} + +/// A set of clauses that we assume to be true. E.g. if we are inside this function: +/// ```rust +/// fn foo<T: Default>(t: T) {} +/// ``` +/// we assume that `T: Default`. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TraitEnvironment { + pub krate: CrateId, + // FIXME make this a BTreeMap + pub(crate) traits_from_clauses: Vec<(Ty, TraitId)>, + pub env: chalk_ir::Environment<Interner>, +} + +impl TraitEnvironment { + pub fn empty(krate: CrateId) -> Self { + TraitEnvironment { + krate, + traits_from_clauses: Vec::new(), + env: chalk_ir::Environment::new(Interner), + } + } + + pub fn traits_in_scope_from_clauses<'a>( + &'a self, + ty: Ty, + ) -> impl Iterator<Item = TraitId> + 'a { + self.traits_from_clauses + .iter() + .filter_map(move |(self_ty, trait_id)| (*self_ty == ty).then(|| *trait_id)) + } +} + +/// Solve a trait goal using Chalk. +pub(crate) fn trait_solve_query( + db: &dyn HirDatabase, + krate: CrateId, + goal: Canonical<InEnvironment<Goal>>, +) -> Option<Solution> { + let _p = profile::span("trait_solve_query").detail(|| match &goal.value.goal.data(Interner) { + GoalData::DomainGoal(DomainGoal::Holds(WhereClause::Implemented(it))) => { + db.trait_data(it.hir_trait_id()).name.to_string() + } + GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(_))) => "alias_eq".to_string(), + _ => "??".to_string(), + }); + tracing::info!("trait_solve_query({:?})", goal.value.goal); + + if let GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(AliasEq { + alias: AliasTy::Projection(projection_ty), + .. + }))) = &goal.value.goal.data(Interner) + { + if let TyKind::BoundVar(_) = projection_ty.self_type_parameter(Interner).kind(Interner) { + // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible + return Some(Solution::Ambig(Guidance::Unknown)); + } + } + + // We currently don't deal with universes (I think / hope they're not yet + // relevant for our use cases?) + let u_canonical = chalk_ir::UCanonical { canonical: goal, universes: 1 }; + solve(db, krate, &u_canonical) +} + +fn solve( + db: &dyn HirDatabase, + krate: CrateId, + goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>, +) -> Option<chalk_solve::Solution<Interner>> { + let context = ChalkContext { db, krate }; + tracing::debug!("solve goal: {:?}", goal); + let mut solver = create_chalk_solver(); + + let fuel = std::cell::Cell::new(CHALK_SOLVER_FUEL); + + let should_continue = || { + db.unwind_if_cancelled(); + let remaining = fuel.get(); + fuel.set(remaining - 1); + if remaining == 0 { + tracing::debug!("fuel exhausted"); + } + remaining > 0 + }; + + let mut solve = || { + let _ctx = if is_chalk_debug() || is_chalk_print() { + Some(panic_context::enter(format!("solving {:?}", goal))) + } else { + None + }; + let solution = if is_chalk_print() { + let logging_db = + LoggingRustIrDatabaseLoggingOnDrop(LoggingRustIrDatabase::new(context)); + solver.solve_limited(&logging_db.0, goal, &should_continue) + } else { + solver.solve_limited(&context, goal, &should_continue) + }; + + tracing::debug!("solve({:?}) => {:?}", goal, solution); + + solution + }; + + // don't set the TLS for Chalk unless Chalk debugging is active, to make + // extra sure we only use it for debugging + if is_chalk_debug() { + crate::tls::set_current_program(db, solve) + } else { + solve() + } +} + +struct LoggingRustIrDatabaseLoggingOnDrop<'a>(LoggingRustIrDatabase<Interner, ChalkContext<'a>>); + +impl<'a> Drop for LoggingRustIrDatabaseLoggingOnDrop<'a> { + fn drop(&mut self) { + eprintln!("chalk program:\n{}", self.0); + } +} + +fn is_chalk_debug() -> bool { + std::env::var("CHALK_DEBUG").is_ok() +} + +fn is_chalk_print() -> bool { + std::env::var("CHALK_PRINT").is_ok() +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum FnTrait { + FnOnce, + FnMut, + Fn, +} + +impl FnTrait { + const fn lang_item_name(self) -> &'static str { + match self { + FnTrait::FnOnce => "fn_once", + FnTrait::FnMut => "fn_mut", + FnTrait::Fn => "fn", + } + } + + pub fn get_id(&self, db: &dyn HirDatabase, krate: CrateId) -> Option<TraitId> { + let target = db.lang_item(krate, SmolStr::new_inline(self.lang_item_name()))?; + match target { + LangItemTarget::TraitId(t) => Some(t), + _ => None, + } + } +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs new file mode 100644 index 000000000..83319755d --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs @@ -0,0 +1,408 @@ +//! Helper functions for working with def, which don't need to be a separate +//! query, but can't be computed directly from `*Data` (ie, which need a `db`). + +use std::iter; + +use base_db::CrateId; +use chalk_ir::{fold::Shift, BoundVar, DebruijnIndex}; +use hir_def::{ + db::DefDatabase, + generics::{ + GenericParams, TypeOrConstParamData, TypeParamProvenance, WherePredicate, + WherePredicateTypeTarget, + }, + intern::Interned, + resolver::{HasResolver, TypeNs}, + type_ref::{TraitBoundModifier, TypeRef}, + ConstParamId, FunctionId, GenericDefId, ItemContainerId, Lookup, TraitId, TypeAliasId, + TypeOrConstParamId, TypeParamId, +}; +use hir_expand::name::{known, Name}; +use itertools::Either; +use rustc_hash::FxHashSet; +use smallvec::{smallvec, SmallVec}; +use syntax::SmolStr; + +use crate::{ + db::HirDatabase, ChalkTraitId, ConstData, ConstValue, GenericArgData, Interner, Substitution, + TraitRef, TraitRefExt, TyKind, WhereClause, +}; + +pub(crate) fn fn_traits(db: &dyn DefDatabase, krate: CrateId) -> impl Iterator<Item = TraitId> { + [ + db.lang_item(krate, SmolStr::new_inline("fn")), + db.lang_item(krate, SmolStr::new_inline("fn_mut")), + db.lang_item(krate, SmolStr::new_inline("fn_once")), + ] + .into_iter() + .flatten() + .flat_map(|it| it.as_trait()) +} + +fn direct_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> SmallVec<[TraitId; 4]> { + let resolver = trait_.resolver(db); + // returning the iterator directly doesn't easily work because of + // lifetime problems, but since there usually shouldn't be more than a + // few direct traits this should be fine (we could even use some kind of + // SmallVec if performance is a concern) + let generic_params = db.generic_params(trait_.into()); + let trait_self = generic_params.find_trait_self_param(); + generic_params + .where_predicates + .iter() + .filter_map(|pred| match pred { + WherePredicate::ForLifetime { target, bound, .. } + | WherePredicate::TypeBound { target, bound } => { + let is_trait = match target { + WherePredicateTypeTarget::TypeRef(type_ref) => match &**type_ref { + TypeRef::Path(p) => p.is_self_type(), + _ => false, + }, + WherePredicateTypeTarget::TypeOrConstParam(local_id) => { + Some(*local_id) == trait_self + } + }; + match is_trait { + true => bound.as_path(), + false => None, + } + } + WherePredicate::Lifetime { .. } => None, + }) + .filter(|(_, bound_modifier)| matches!(bound_modifier, TraitBoundModifier::None)) + .filter_map(|(path, _)| match resolver.resolve_path_in_type_ns_fully(db, path.mod_path()) { + Some(TypeNs::TraitId(t)) => Some(t), + _ => None, + }) + .collect() +} + +fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<TraitRef> { + // returning the iterator directly doesn't easily work because of + // lifetime problems, but since there usually shouldn't be more than a + // few direct traits this should be fine (we could even use some kind of + // SmallVec if performance is a concern) + let generic_params = db.generic_params(trait_ref.hir_trait_id().into()); + let trait_self = match generic_params.find_trait_self_param() { + Some(p) => TypeOrConstParamId { parent: trait_ref.hir_trait_id().into(), local_id: p }, + None => return Vec::new(), + }; + db.generic_predicates_for_param(trait_self.parent, trait_self, None) + .iter() + .filter_map(|pred| { + pred.as_ref().filter_map(|pred| match pred.skip_binders() { + // FIXME: how to correctly handle higher-ranked bounds here? + WhereClause::Implemented(tr) => Some( + tr.clone() + .shifted_out_to(Interner, DebruijnIndex::ONE) + .expect("FIXME unexpected higher-ranked trait bound"), + ), + _ => None, + }) + }) + .map(|pred| pred.substitute(Interner, &trait_ref.substitution)) + .collect() +} + +/// Returns an iterator over the whole super trait hierarchy (including the +/// trait itself). +pub fn all_super_traits(db: &dyn DefDatabase, trait_: TraitId) -> SmallVec<[TraitId; 4]> { + // we need to take care a bit here to avoid infinite loops in case of cycles + // (i.e. if we have `trait A: B; trait B: A;`) + + let mut result = smallvec![trait_]; + let mut i = 0; + while let Some(&t) = result.get(i) { + // yeah this is quadratic, but trait hierarchies should be flat + // enough that this doesn't matter + for tt in direct_super_traits(db, t) { + if !result.contains(&tt) { + result.push(tt); + } + } + i += 1; + } + result +} + +/// Given a trait ref (`Self: Trait`), builds all the implied trait refs for +/// super traits. The original trait ref will be included. So the difference to +/// `all_super_traits` is that we keep track of type parameters; for example if +/// we have `Self: Trait<u32, i32>` and `Trait<T, U>: OtherTrait<U>` we'll get +/// `Self: OtherTrait<i32>`. +pub(super) fn all_super_trait_refs(db: &dyn HirDatabase, trait_ref: TraitRef) -> SuperTraits<'_> { + SuperTraits { db, seen: iter::once(trait_ref.trait_id).collect(), stack: vec![trait_ref] } +} + +pub(super) struct SuperTraits<'a> { + db: &'a dyn HirDatabase, + stack: Vec<TraitRef>, + seen: FxHashSet<ChalkTraitId>, +} + +impl<'a> SuperTraits<'a> { + fn elaborate(&mut self, trait_ref: &TraitRef) { + let mut trait_refs = direct_super_trait_refs(self.db, trait_ref); + trait_refs.retain(|tr| !self.seen.contains(&tr.trait_id)); + self.stack.extend(trait_refs); + } +} + +impl<'a> Iterator for SuperTraits<'a> { + type Item = TraitRef; + + fn next(&mut self) -> Option<Self::Item> { + if let Some(next) = self.stack.pop() { + self.elaborate(&next); + Some(next) + } else { + None + } + } +} + +pub(super) fn associated_type_by_name_including_super_traits( + db: &dyn HirDatabase, + trait_ref: TraitRef, + name: &Name, +) -> Option<(TraitRef, TypeAliasId)> { + all_super_trait_refs(db, trait_ref).find_map(|t| { + let assoc_type = db.trait_data(t.hir_trait_id()).associated_type_by_name(name)?; + Some((t, assoc_type)) + }) +} + +pub(crate) fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics { + let parent_generics = parent_generic_def(db, def).map(|def| Box::new(generics(db, def))); + if parent_generics.is_some() && matches!(def, GenericDefId::TypeAliasId(_)) { + let params = db.generic_params(def); + let has_consts = + params.iter().any(|(_, x)| matches!(x, TypeOrConstParamData::ConstParamData(_))); + return if has_consts { + // XXX: treat const generic associated types as not existing to avoid crashes (#11769) + // + // Chalk expects the inner associated type's parameters to come + // *before*, not after the trait's generics as we've always done it. + // Adapting to this requires a larger refactoring + cov_mark::hit!(ignore_gats); + Generics { def, params: Interned::new(Default::default()), parent_generics } + } else { + Generics { def, params, parent_generics } + }; + } + Generics { def, params: db.generic_params(def), parent_generics } +} + +#[derive(Debug)] +pub(crate) struct Generics { + def: GenericDefId, + pub(crate) params: Interned<GenericParams>, + parent_generics: Option<Box<Generics>>, +} + +impl Generics { + pub(crate) fn iter_id<'a>( + &'a self, + ) -> impl Iterator<Item = Either<TypeParamId, ConstParamId>> + 'a { + self.iter().map(|(id, data)| match data { + TypeOrConstParamData::TypeParamData(_) => Either::Left(TypeParamId::from_unchecked(id)), + TypeOrConstParamData::ConstParamData(_) => { + Either::Right(ConstParamId::from_unchecked(id)) + } + }) + } + + /// Iterator over types and const params of parent, then self. + pub(crate) fn iter<'a>( + &'a self, + ) -> impl DoubleEndedIterator<Item = (TypeOrConstParamId, &'a TypeOrConstParamData)> + 'a { + let to_toc_id = |it: &'a Generics| { + move |(local_id, p)| (TypeOrConstParamId { parent: it.def, local_id }, p) + }; + self.parent_generics() + .into_iter() + .flat_map(move |it| it.params.iter().map(to_toc_id(it))) + .chain(self.params.iter().map(to_toc_id(self))) + } + + /// Iterator over types and const params of parent. + pub(crate) fn iter_parent<'a>( + &'a self, + ) -> impl Iterator<Item = (TypeOrConstParamId, &'a TypeOrConstParamData)> + 'a { + self.parent_generics().into_iter().flat_map(|it| { + let to_toc_id = + move |(local_id, p)| (TypeOrConstParamId { parent: it.def, local_id }, p); + it.params.iter().map(to_toc_id) + }) + } + + pub(crate) fn len(&self) -> usize { + let parent = self.parent_generics().map_or(0, Generics::len); + let child = self.params.type_or_consts.len(); + parent + child + } + + /// (parent total, self param, type param list, const param list, impl trait) + pub(crate) fn provenance_split(&self) -> (usize, usize, usize, usize, usize) { + let ty_iter = || self.params.iter().filter_map(|x| x.1.type_param()); + + let self_params = + ty_iter().filter(|p| p.provenance == TypeParamProvenance::TraitSelf).count(); + let type_params = + ty_iter().filter(|p| p.provenance == TypeParamProvenance::TypeParamList).count(); + let impl_trait_params = + ty_iter().filter(|p| p.provenance == TypeParamProvenance::ArgumentImplTrait).count(); + let const_params = self.params.iter().filter_map(|x| x.1.const_param()).count(); + + let parent_len = self.parent_generics().map_or(0, Generics::len); + (parent_len, self_params, type_params, const_params, impl_trait_params) + } + + pub(crate) fn param_idx(&self, param: TypeOrConstParamId) -> Option<usize> { + Some(self.find_param(param)?.0) + } + + fn find_param(&self, param: TypeOrConstParamId) -> Option<(usize, &TypeOrConstParamData)> { + if param.parent == self.def { + let (idx, (_local_id, data)) = self + .params + .iter() + .enumerate() + .find(|(_, (idx, _))| *idx == param.local_id) + .unwrap(); + let parent_len = self.parent_generics().map_or(0, Generics::len); + Some((parent_len + idx, data)) + } else { + self.parent_generics().and_then(|g| g.find_param(param)) + } + } + + fn parent_generics(&self) -> Option<&Generics> { + self.parent_generics.as_ref().map(|it| &**it) + } + + /// Returns a Substitution that replaces each parameter by a bound variable. + pub(crate) fn bound_vars_subst( + &self, + db: &dyn HirDatabase, + debruijn: DebruijnIndex, + ) -> Substitution { + Substitution::from_iter( + Interner, + self.iter_id().enumerate().map(|(idx, id)| match id { + Either::Left(_) => GenericArgData::Ty( + TyKind::BoundVar(BoundVar::new(debruijn, idx)).intern(Interner), + ) + .intern(Interner), + Either::Right(id) => GenericArgData::Const( + ConstData { + value: ConstValue::BoundVar(BoundVar::new(debruijn, idx)), + ty: db.const_param_ty(id), + } + .intern(Interner), + ) + .intern(Interner), + }), + ) + } + + /// Returns a Substitution that replaces each parameter by itself (i.e. `Ty::Param`). + pub(crate) fn placeholder_subst(&self, db: &dyn HirDatabase) -> Substitution { + Substitution::from_iter( + Interner, + self.iter_id().map(|id| match id { + Either::Left(id) => GenericArgData::Ty( + TyKind::Placeholder(crate::to_placeholder_idx(db, id.into())).intern(Interner), + ) + .intern(Interner), + Either::Right(id) => GenericArgData::Const( + ConstData { + value: ConstValue::Placeholder(crate::to_placeholder_idx(db, id.into())), + ty: db.const_param_ty(id), + } + .intern(Interner), + ) + .intern(Interner), + }), + ) + } +} + +fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Option<GenericDefId> { + let container = match def { + GenericDefId::FunctionId(it) => it.lookup(db).container, + GenericDefId::TypeAliasId(it) => it.lookup(db).container, + GenericDefId::ConstId(it) => it.lookup(db).container, + GenericDefId::EnumVariantId(it) => return Some(it.parent.into()), + GenericDefId::AdtId(_) | GenericDefId::TraitId(_) | GenericDefId::ImplId(_) => return None, + }; + + match container { + ItemContainerId::ImplId(it) => Some(it.into()), + ItemContainerId::TraitId(it) => Some(it.into()), + ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => None, + } +} + +pub fn is_fn_unsafe_to_call(db: &dyn HirDatabase, func: FunctionId) -> bool { + let data = db.function_data(func); + if data.has_unsafe_kw() { + return true; + } + + match func.lookup(db.upcast()).container { + hir_def::ItemContainerId::ExternBlockId(block) => { + // Function in an `extern` block are always unsafe to call, except when it has + // `"rust-intrinsic"` ABI there are a few exceptions. + let id = block.lookup(db.upcast()).id; + !matches!( + id.item_tree(db.upcast())[id.value].abi.as_deref(), + Some("rust-intrinsic") if !is_intrinsic_fn_unsafe(&data.name) + ) + } + _ => false, + } +} + +/// Returns `true` if the given intrinsic is unsafe to call, or false otherwise. +fn is_intrinsic_fn_unsafe(name: &Name) -> bool { + // Should be kept in sync with https://github.com/rust-lang/rust/blob/532d2b14c05f9bc20b2d27cbb5f4550d28343a36/compiler/rustc_typeck/src/check/intrinsic.rs#L72-L106 + ![ + known::abort, + known::add_with_overflow, + known::bitreverse, + known::black_box, + known::bswap, + known::caller_location, + known::ctlz, + known::ctpop, + known::cttz, + known::discriminant_value, + known::forget, + known::likely, + known::maxnumf32, + known::maxnumf64, + known::min_align_of, + known::minnumf32, + known::minnumf64, + known::mul_with_overflow, + known::needs_drop, + known::ptr_guaranteed_eq, + known::ptr_guaranteed_ne, + known::rotate_left, + known::rotate_right, + known::rustc_peek, + known::saturating_add, + known::saturating_sub, + known::size_of, + known::sub_with_overflow, + known::type_id, + known::type_name, + known::unlikely, + known::variant_count, + known::wrapping_add, + known::wrapping_mul, + known::wrapping_sub, + ] + .contains(name) +} diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/walk.rs b/src/tools/rust-analyzer/crates/hir-ty/src/walk.rs new file mode 100644 index 000000000..c47689455 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-ty/src/walk.rs @@ -0,0 +1,147 @@ +//! The `TypeWalk` trait (probably to be replaced by Chalk's `Fold` and +//! `Visit`). + +use chalk_ir::interner::HasInterner; + +use crate::{ + AliasEq, AliasTy, Binders, CallableSig, FnSubst, GenericArg, GenericArgData, Interner, + OpaqueTy, ProjectionTy, Substitution, TraitRef, Ty, TyKind, WhereClause, +}; + +/// This allows walking structures that contain types to do something with those +/// types, similar to Chalk's `Fold` trait. +pub trait TypeWalk { + fn walk(&self, f: &mut impl FnMut(&Ty)); +} + +impl TypeWalk for Ty { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + match self.kind(Interner) { + TyKind::Alias(AliasTy::Projection(p_ty)) => { + for t in p_ty.substitution.iter(Interner) { + t.walk(f); + } + } + TyKind::Alias(AliasTy::Opaque(o_ty)) => { + for t in o_ty.substitution.iter(Interner) { + t.walk(f); + } + } + TyKind::Dyn(dyn_ty) => { + for p in dyn_ty.bounds.skip_binders().interned().iter() { + p.walk(f); + } + } + TyKind::Slice(ty) + | TyKind::Array(ty, _) + | TyKind::Ref(_, _, ty) + | TyKind::Raw(_, ty) => { + ty.walk(f); + } + TyKind::Function(fn_pointer) => { + fn_pointer.substitution.0.walk(f); + } + TyKind::Adt(_, substs) + | TyKind::FnDef(_, substs) + | TyKind::Tuple(_, substs) + | TyKind::OpaqueType(_, substs) + | TyKind::AssociatedType(_, substs) + | TyKind::Closure(.., substs) => { + substs.walk(f); + } + _ => {} + } + f(self); + } +} + +impl<T: TypeWalk> TypeWalk for Vec<T> { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + for t in self { + t.walk(f); + } + } +} + +impl TypeWalk for OpaqueTy { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + self.substitution.walk(f); + } +} + +impl TypeWalk for ProjectionTy { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + self.substitution.walk(f); + } +} + +impl TypeWalk for AliasTy { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + match self { + AliasTy::Projection(it) => it.walk(f), + AliasTy::Opaque(it) => it.walk(f), + } + } +} + +impl TypeWalk for GenericArg { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + if let GenericArgData::Ty(ty) = &self.interned() { + ty.walk(f); + } + } +} + +impl TypeWalk for Substitution { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + for t in self.iter(Interner) { + t.walk(f); + } + } +} + +impl<T: TypeWalk + HasInterner<Interner = Interner>> TypeWalk for Binders<T> { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + self.skip_binders().walk(f); + } +} + +impl TypeWalk for TraitRef { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + self.substitution.walk(f); + } +} + +impl TypeWalk for WhereClause { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + match self { + WhereClause::Implemented(trait_ref) => trait_ref.walk(f), + WhereClause::AliasEq(alias_eq) => alias_eq.walk(f), + _ => {} + } + } +} + +impl TypeWalk for CallableSig { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + for t in self.params_and_return.iter() { + t.walk(f); + } + } +} + +impl TypeWalk for AliasEq { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + self.ty.walk(f); + match &self.alias { + AliasTy::Projection(projection_ty) => projection_ty.walk(f), + AliasTy::Opaque(opaque) => opaque.walk(f), + } + } +} + +impl TypeWalk for FnSubst<Interner> { + fn walk(&self, f: &mut impl FnMut(&Ty)) { + self.0.walk(f) + } +} |