Refactor handling of generic params in hir::Type

The essence of the new handling is that `hir::Type` now remembers its owner (and not `ParamEnv`; we could remember both but that is unnecessary) and refuse (panics) to work with types not from the same owner. It would be best if we could enforce this statically, but unfortunately we can't.

Author: ChayimFriedman2

crates/hir-ty/src/traits.rs

@@ -121,7 +121,7 @@ pub fn implements_trait_unique<'db>(
     env: ParamEnvAndCrate<'db>,
     trait_: TraitId,
 ) -> bool {
-    implements_trait_unique_impl(db, env, trait_, &mut |infcx| {
+    implements_trait_unique_with_infcx(db, env, trait_, &mut |infcx| {
         infcx.fill_rest_fresh_args(Span::Dummy, trait_.into(), [ty.into()])
     })
 }
@@ -133,10 +133,10 @@ pub fn implements_trait_unique_with_args<'db>(
     trait_: TraitId,
     args: GenericArgs<'db>,
 ) -> bool {
-    implements_trait_unique_impl(db, env, trait_, &mut |_| args)
+    implements_trait_unique_with_infcx(db, env, trait_, &mut |_| args)
 }
 
-fn implements_trait_unique_impl<'db>(
+pub fn implements_trait_unique_with_infcx<'db>(
     db: &'db dyn HirDatabase,
     env: ParamEnvAndCrate<'db>,
     trait_: TraitId,

crates/hir/src/attrs.rs

@@ -26,8 +26,8 @@ use stdx::never;
 
 use crate::{
     Adt, AsAssocItem, AssocItem, BuiltinType, Const, ConstParam, DocLinkDef, Enum, EnumVariant,
-    ExternCrateDecl, Field, Function, GenericParam, HasCrate, Impl, LangItem, LifetimeParam, Macro,
-    Module, ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant,
+    ExternCrateDecl, Field, Function, GenericParam, Impl, LangItem, LifetimeParam, Macro, Module,
+    ModuleDef, Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant,
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -487,27 +487,28 @@ fn resolve_impl_trait_item<'db>(
     ns: Option<Namespace>,
 ) -> Option<DocLinkDef> {
     let krate = ty.krate(db);
-    let environment = crate::param_env_from_resolver(db, &resolver);
+    let param_env = ty.param_env(db);
     let traits_in_scope = resolver.traits_in_scope(db);
 
     // `ty.iterate_path_candidates()` require a scope, which is not available when resolving
     // attributes here. Use path resolution directly instead.
     //
     // FIXME: resolve type aliases (which are not yielded by iterate_path_candidates)
-    let interner = DbInterner::new_with(db, environment.krate);
+    let interner = DbInterner::new_with(db, param_env.krate);
     let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let features = resolver.top_level_def_map().features();
     let ctx = MethodResolutionContext {
         infcx: &infcx,
         resolver: &resolver,
-        param_env: environment.param_env,
+        param_env: param_env.param_env,
         traits_in_scope: &traits_in_scope,
-        edition: krate.edition(db),
+        edition: krate.data(db).edition,
         features,
         call_span: hir_ty::Span::Dummy,
         receiver_span: hir_ty::Span::Dummy,
     };
-    let resolution = ctx.probe_for_name(method_resolution::Mode::Path, name.clone(), ty.ty);
+    let resolution =
+        ctx.probe_for_name(method_resolution::Mode::Path, name.clone(), ty.ty.skip_binder());
     let resolution = match resolution {
         Ok(resolution) => resolution.item,
         Err(MethodError::PrivateMatch(resolution)) => resolution.item,

crates/hir/src/diagnostics.rs

@@ -16,12 +16,11 @@ use hir_def::{
 use hir_expand::{HirFileId, InFile, mod_path::ModPath, name::Name};
 use hir_ty::{
     CastError, ExplicitDropMethodUseKind, InferenceDiagnostic, InferenceTyDiagnosticSource,
-    ParamEnvAndCrate, PathGenericsSource, PathLoweringDiagnostic, TyLoweringDiagnostic,
-    TyLoweringDiagnosticKind,
+    PathGenericsSource, PathLoweringDiagnostic, TyLoweringDiagnostic, TyLoweringDiagnosticKind,
     db::HirDatabase,
     diagnostics::{BodyValidationDiagnostic, UnsafetyReason},
     display::{DisplayTarget, HirDisplay},
-    next_solver::DbInterner,
+    next_solver::{DbInterner, EarlyBinder},
     solver_errors::SolverDiagnosticKind,
 };
 use stdx::{impl_from, never};
@@ -32,7 +31,7 @@ use syntax::{
 };
 use triomphe::Arc;
 
-use crate::{AssocItem, Field, Function, GenericDef, Local, Trait, Type, Variant};
+use crate::{AssocItem, Field, Function, GenericDef, Local, Trait, Type, TypeOwnerId, Variant};
 
 pub use hir_def::VariantId;
 pub use hir_ty::{
@@ -791,7 +790,7 @@ impl<'db> AnyDiagnostic<'db> {
         d: &'db InferenceDiagnostic,
         source_map: &hir_def::expr_store::BodySourceMap,
         sig_map: &hir_def::expr_store::ExpressionStoreSourceMap,
-        env: ParamEnvAndCrate<'db>,
+        type_owner: TypeOwnerId,
     ) -> Option<AnyDiagnostic<'db>> {
         let expr_syntax = |expr| {
             source_map
@@ -815,6 +814,7 @@ impl<'db> AnyDiagnostic<'db> {
             ExprOrPatId::ExprId(expr) => expr_syntax(expr),
             ExprOrPatId::PatId(pat) => pat_syntax(pat),
         };
+        let new_ty = |ty| Type { owner: type_owner, ty: EarlyBinder::bind(ty) };
         let span_syntax = |span| match span {
             hir_ty::Span::ExprId(idx) => expr_syntax(idx).map(|it| it.upcast()),
             hir_ty::Span::PatId(idx) => pat_syntax(idx).map(|it| it.upcast()),
@@ -848,7 +848,11 @@ impl<'db> AnyDiagnostic<'db> {
             }
             InferenceDiagnostic::ExpectedArrayOrSlicePat { pat, found } => {
                 let pat = pat_syntax(*pat)?.map(Into::into);
-                ExpectedArrayOrSlicePat { pat, found: Type::new(db, def, found.as_ref()) }.into()
+                ExpectedArrayOrSlicePat {
+                    pat,
+                    found: Type { owner: type_owner, ty: EarlyBinder::bind(found.as_ref()) },
+                }
+                .into()
             }
             &InferenceDiagnostic::InvalidRangePatType { pat } => {
                 let pat = pat_syntax(pat)?.map(Into::into);
@@ -878,8 +882,7 @@ impl<'db> AnyDiagnostic<'db> {
             }
             InferenceDiagnostic::ExpectedFunction { call_expr, found } => {
                 let call_expr = expr_syntax(*call_expr)?;
-                ExpectedFunction { call: call_expr, found: Type::new(db, def, found.as_ref()) }
-                    .into()
+                ExpectedFunction { call: call_expr, found: new_ty(found.as_ref()) }.into()
             }
             InferenceDiagnostic::UnresolvedField {
                 expr,
@@ -891,7 +894,7 @@ impl<'db> AnyDiagnostic<'db> {
                 UnresolvedField {
                     expr,
                     name: name.clone(),
-                    receiver: Type::new(db, def, receiver.as_ref()),
+                    receiver: new_ty(receiver.as_ref()),
                     method_with_same_name_exists: *method_with_same_name_exists,
                 }
                 .into()
@@ -907,10 +910,10 @@ impl<'db> AnyDiagnostic<'db> {
                 UnresolvedMethodCall {
                     expr,
                     name: name.clone(),
-                    receiver: Type::new(db, def, receiver.as_ref()),
+                    receiver: new_ty(receiver.as_ref()),
                     field_with_same_name: field_with_same_name
                         .as_ref()
-                        .map(|ty| Type::new(db, def, ty.as_ref())),
+                        .map(|ty| new_ty(ty.as_ref())),
                     assoc_func_with_same_name: assoc_func_with_same_name.map(Into::into),
                 }
                 .into()
@@ -947,7 +950,7 @@ impl<'db> AnyDiagnostic<'db> {
             }
             InferenceDiagnostic::TypedHole { expr, expected } => {
                 let expr = expr_syntax(*expr)?;
-                TypedHole { expr, expected: Type::new(db, def, expected.as_ref()) }.into()
+                TypedHole { expr, expected: new_ty(expected.as_ref()) }.into()
             }
             &InferenceDiagnostic::MismatchedTupleStructPatArgCount { pat, expected, found } => {
                 let InFile { file_id, value } = pat_syntax(pat)?;
@@ -958,21 +961,21 @@ impl<'db> AnyDiagnostic<'db> {
             }
             InferenceDiagnostic::CastToUnsized { expr, cast_ty } => {
                 let expr = expr_syntax(*expr)?;
-                CastToUnsized { expr, cast_ty: Type::new(db, def, cast_ty.as_ref()) }.into()
+                CastToUnsized { expr, cast_ty: new_ty(cast_ty.as_ref()) }.into()
             }
             InferenceDiagnostic::InvalidCast { expr, error, expr_ty, cast_ty } => {
                 let expr = expr_syntax(*expr)?;
-                let expr_ty = Type::new(db, def, expr_ty.as_ref());
-                let cast_ty = Type::new(db, def, cast_ty.as_ref());
+                let expr_ty = new_ty(expr_ty.as_ref());
+                let cast_ty = new_ty(cast_ty.as_ref());
                 InvalidCast { expr, error: *error, expr_ty, cast_ty }.into()
             }
             InferenceDiagnostic::CannotBeDereferenced { expr, found } => {
                 let expr = expr_syntax(*expr)?;
-                CannotBeDereferenced { expr, found: Type::new(db, def, found.as_ref()) }.into()
+                CannotBeDereferenced { expr, found: new_ty(found.as_ref()) }.into()
             }
             InferenceDiagnostic::CannotIndexInto { expr, found } => {
                 let expr = expr_syntax(*expr)?;
-                CannotIndexInto { expr, found: Type::new(db, def, found.as_ref()) }.into()
+                CannotIndexInto { expr, found: new_ty(found.as_ref()) }.into()
             }
             InferenceDiagnostic::TyDiagnostic { source, diag } => {
                 let source_map = match source {
@@ -1047,10 +1050,7 @@ impl<'db> AnyDiagnostic<'db> {
             &InferenceDiagnostic::TypeMustBeKnown { at_point, ref top_term } => {
                 let at_point = span_syntax(at_point)?;
                 let top_term = top_term.as_ref().map(|top_term| match top_term.as_ref().kind() {
-                    rustc_type_ir::GenericArgKind::Type(ty) => Either::Left(Type {
-                        ty,
-                        env: crate::body_param_env_from_has_crate(db, def),
-                    }),
+                    rustc_type_ir::GenericArgKind::Type(ty) => Either::Left(new_ty(ty)),
                     // FIXME: Printing the const to string is definitely not the correct thing to do here.
                     rustc_type_ir::GenericArgKind::Const(konst) => Either::Right(
                         konst.display(db, DisplayTarget::from_crate(db, def.krate(db))).to_string(),
@@ -1069,14 +1069,14 @@ impl<'db> AnyDiagnostic<'db> {
                 let expr_or_pat = expr_or_pat_syntax(*node)?;
                 TypeMismatch {
                     expr_or_pat,
-                    expected: Type { env, ty: expected.as_ref() },
-                    actual: Type { env, ty: found.as_ref() },
+                    expected: Type { owner: type_owner, ty: EarlyBinder::bind(expected.as_ref()) },
+                    actual: Type { owner: type_owner, ty: EarlyBinder::bind(found.as_ref()) },
                 }
                 .into()
             }
             InferenceDiagnostic::SolverDiagnostic(d) => {
                 let span = span_syntax(d.span)?;
-                Self::solver_diagnostic(db, &d.kind, span, env)?
+                Self::solver_diagnostic(db, &d.kind, span, type_owner)?
             }
             InferenceDiagnostic::ExplicitDropMethodUse { kind } => {
                 let expr_or_path = match kind {
@@ -1108,16 +1108,21 @@ impl<'db> AnyDiagnostic<'db> {
         db: &'db dyn HirDatabase,
         d: &'db SolverDiagnosticKind,
         span: SpanSyntax,
-        env: ParamEnvAndCrate<'db>,
+        type_owner: TypeOwnerId,
     ) -> Option<AnyDiagnostic<'db>> {
         let interner = DbInterner::new_no_crate(db);
         Some(match d {
             SolverDiagnosticKind::TraitUnimplemented { trait_predicate, root_trait_predicate } => {
-                let trait_predicate =
-                    crate::TraitPredicate { inner: trait_predicate.get(interner), env };
+                let trait_predicate = crate::TraitPredicate {
+                    inner: trait_predicate.get(interner),
+                    owner: type_owner,
+                };
                 let root_trait_predicate =
                     root_trait_predicate.as_ref().map(|root_trait_predicate| {
-                        crate::TraitPredicate { inner: root_trait_predicate.get(interner), env }
+                        crate::TraitPredicate {
+                            inner: root_trait_predicate.get(interner),
+                            owner: type_owner,
+                        }
                     });
                 UnimplementedTrait { span, trait_predicate, root_trait_predicate }.into()
             }

crates/hir/src/display.rs

@@ -33,7 +33,7 @@ use crate::{
     Adt, AnyFunctionId, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum,
     EnumVariant, ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl,
     LifetimeParam, Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitPredicate,
-    TraitRef, TupleField, Type, TypeAlias, TypeNs, TypeOrConstParam, TypeParam, Union,
+    TraitRef, TupleField, Type, TypeAlias, TypeOrConstParam, TypeParam, Union,
 };
 
 fn write_builtin_derive_impl_method<'db>(
@@ -552,13 +552,7 @@ impl<'db> HirDisplay<'db> for EnumVariant {
 
 impl<'db> HirDisplay<'db> for Type<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
-        self.ty.hir_fmt(f)
-    }
-}
-
-impl<'db> HirDisplay<'db> for TypeNs<'db> {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_, 'db>) -> Result {
-        self.ty.hir_fmt(f)
+        self.ty.skip_binder().hir_fmt(f)
     }
 }
 
@@ -598,7 +592,7 @@ impl<'db> HirDisplay<'db> for TypeParam {
         let params = GenericParams::of(f.db, self.id.parent());
         let param_data = &params[self.id.local_id()];
         let krate = self.id.parent().krate(f.db).id;
-        let ty = self.ty(f.db).ty;
+        let ty = self.ty(f.db).ty.skip_binder();
         let predicates = GenericPredicates::query_all(f.db, self.id.parent());
         let predicates = predicates
             .iter_identity()