Merge pull request #21307 from ChayimFriedman2/more-perf-work

perf: More perf improvements, made possible after non-Salsa interneds

Author: ChayimFriedman2

crates/hir-ty/src/display.rs

@@ -1459,7 +1459,7 @@ impl<'db> HirDisplay<'db> for Ty<'db> {
                 };
                 let coroutine_sig = coroutine_sig.skip_binder();
                 let coroutine_inputs = coroutine_sig.inputs();
-                let TyKind::Tuple(coroutine_inputs) = coroutine_inputs.as_slice()[1].kind() else {
+                let TyKind::Tuple(coroutine_inputs) = coroutine_inputs[1].kind() else {
                     unreachable!("invalid coroutine closure signature");
                 };
                 let TyKind::Tuple(coroutine_output) = coroutine_sig.output().kind() else {
@@ -1942,7 +1942,7 @@ fn write_bounds_like_dyn_trait<'db>(
                 let own_args = projection.projection_term.own_args(f.interner);
                 if !own_args.is_empty() {
                     write!(f, "<")?;
-                    hir_fmt_generic_arguments(f, own_args.as_slice(), None)?;
+                    hir_fmt_generic_arguments(f, own_args, None)?;
                     write!(f, ">")?;
                 }
                 write!(f, " = ")?;

crates/hir-ty/src/dyn_compatibility.rs

@@ -328,13 +328,9 @@ where
     }
 
     let sig = db.callable_item_signature(func.into());
-    if sig
-        .skip_binder()
-        .inputs()
-        .iter()
-        .skip(1)
-        .any(|ty| contains_illegal_self_type_reference(db, trait_, &ty, AllowSelfProjection::Yes))
-    {
+    if sig.skip_binder().inputs().iter().skip(1).any(|ty| {
+        contains_illegal_self_type_reference(db, trait_, ty.skip_binder(), AllowSelfProjection::Yes)
+    }) {
         cb(MethodViolationCode::ReferencesSelfInput)?;
     }
 
@@ -411,11 +407,11 @@ fn receiver_is_dispatchable<'db>(
 
     // `self: Self` can't be dispatched on, but this is already considered dyn-compatible
     // See rustc's comment on https://github.com/rust-lang/rust/blob/3f121b9461cce02a703a0e7e450568849dfaa074/compiler/rustc_trait_selection/src/traits/object_safety.rs#L433-L437
-    if sig.inputs().iter().next().is_some_and(|p| p.skip_binder() == self_param_ty) {
+    if sig.inputs().iter().next().is_some_and(|p| *p.skip_binder() == self_param_ty) {
         return true;
     }
 
-    let Some(&receiver_ty) = sig.inputs().skip_binder().as_slice().first() else {
+    let Some(&receiver_ty) = sig.inputs().skip_binder().first() else {
         return false;
     };
 

crates/hir-ty/src/infer.rs

@@ -51,7 +51,7 @@ use rustc_ast_ir::Mutability;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustc_type_ir::{
     AliasTyKind, TypeFoldable,
-    inherent::{AdtDef, IntoKind, Region as _, Ty as _},
+    inherent::{AdtDef, IntoKind, Ty as _},
 };
 use span::Edition;
 use stdx::never;
@@ -108,23 +108,23 @@ fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> InferenceResult {
         DefWithBodyId::VariantId(v) => {
             ctx.return_ty = match EnumSignature::variant_body_type(db, v.lookup(db).parent) {
                 hir_def::layout::IntegerType::Pointer(signed) => match signed {
-                    true => ctx.types.isize,
-                    false => ctx.types.usize,
+                    true => ctx.types.types.isize,
+                    false => ctx.types.types.usize,
                 },
                 hir_def::layout::IntegerType::Fixed(size, signed) => match signed {
                     true => match size {
-                        Integer::I8 => ctx.types.i8,
-                        Integer::I16 => ctx.types.i16,
-                        Integer::I32 => ctx.types.i32,
-                        Integer::I64 => ctx.types.i64,
-                        Integer::I128 => ctx.types.i128,
+                        Integer::I8 => ctx.types.types.i8,
+                        Integer::I16 => ctx.types.types.i16,
+                        Integer::I32 => ctx.types.types.i32,
+                        Integer::I64 => ctx.types.types.i64,
+                        Integer::I128 => ctx.types.types.i128,
                     },
                     false => match size {
-                        Integer::I8 => ctx.types.u8,
-                        Integer::I16 => ctx.types.u16,
-                        Integer::I32 => ctx.types.u32,
-                        Integer::I64 => ctx.types.u64,
-                        Integer::I128 => ctx.types.u128,
+                        Integer::I8 => ctx.types.types.u8,
+                        Integer::I16 => ctx.types.types.u16,
+                        Integer::I32 => ctx.types.types.u32,
+                        Integer::I64 => ctx.types.types.u64,
+                        Integer::I128 => ctx.types.types.u128,
                     },
                 },
             };
@@ -738,75 +738,6 @@ impl InferenceResult {
     }
 }
 
-#[derive(Debug, Clone)]
-struct InternedStandardTypes<'db> {
-    unit: Ty<'db>,
-    never: Ty<'db>,
-    char: Ty<'db>,
-    bool: Ty<'db>,
-    i8: Ty<'db>,
-    i16: Ty<'db>,
-    i32: Ty<'db>,
-    i64: Ty<'db>,
-    i128: Ty<'db>,
-    isize: Ty<'db>,
-    u8: Ty<'db>,
-    u16: Ty<'db>,
-    u32: Ty<'db>,
-    u64: Ty<'db>,
-    u128: Ty<'db>,
-    usize: Ty<'db>,
-    f16: Ty<'db>,
-    f32: Ty<'db>,
-    f64: Ty<'db>,
-    f128: Ty<'db>,
-    static_str_ref: Ty<'db>,
-    error: Ty<'db>,
-
-    re_static: Region<'db>,
-    re_error: Region<'db>,
-    re_erased: Region<'db>,
-
-    empty_args: GenericArgs<'db>,
-}
-
-impl<'db> InternedStandardTypes<'db> {
-    fn new(interner: DbInterner<'db>) -> Self {
-        let str = Ty::new(interner, rustc_type_ir::TyKind::Str);
-        let re_static = Region::new_static(interner);
-        Self {
-            unit: Ty::new_unit(interner),
-            never: Ty::new(interner, TyKind::Never),
-            char: Ty::new(interner, TyKind::Char),
-            bool: Ty::new(interner, TyKind::Bool),
-            i8: Ty::new_int(interner, rustc_type_ir::IntTy::I8),
-            i16: Ty::new_int(interner, rustc_type_ir::IntTy::I16),
-            i32: Ty::new_int(interner, rustc_type_ir::IntTy::I32),
-            i64: Ty::new_int(interner, rustc_type_ir::IntTy::I64),
-            i128: Ty::new_int(interner, rustc_type_ir::IntTy::I128),
-            isize: Ty::new_int(interner, rustc_type_ir::IntTy::Isize),
-            u8: Ty::new_uint(interner, rustc_type_ir::UintTy::U8),
-            u16: Ty::new_uint(interner, rustc_type_ir::UintTy::U16),
-            u32: Ty::new_uint(interner, rustc_type_ir::UintTy::U32),
-            u64: Ty::new_uint(interner, rustc_type_ir::UintTy::U64),
-            u128: Ty::new_uint(interner, rustc_type_ir::UintTy::U128),
-            usize: Ty::new_uint(interner, rustc_type_ir::UintTy::Usize),
-            f16: Ty::new_float(interner, rustc_type_ir::FloatTy::F16),
-            f32: Ty::new_float(interner, rustc_type_ir::FloatTy::F32),
-            f64: Ty::new_float(interner, rustc_type_ir::FloatTy::F64),
-            f128: Ty::new_float(interner, rustc_type_ir::FloatTy::F128),
-            static_str_ref: Ty::new_ref(interner, re_static, str, Mutability::Not),
-            error: Ty::new_error(interner, ErrorGuaranteed),
-
-            re_static,
-            re_error: Region::error(interner),
-            re_erased: Region::new_erased(interner),
-
-            empty_args: GenericArgs::empty(interner),
-        }
-    }
-}
-
 /// The inference context contains all information needed during type inference.
 #[derive(Clone, Debug)]
 pub(crate) struct InferenceContext<'body, 'db> {
@@ -841,7 +772,7 @@ pub(crate) struct InferenceContext<'body, 'db> {
     resume_yield_tys: Option<(Ty<'db>, Ty<'db>)>,
     diverges: Diverges,
     breakables: Vec<BreakableContext<'db>>,
-    types: InternedStandardTypes<'db>,
+    types: &'db crate::next_solver::DefaultAny<'db>,
 
     /// Whether we are inside the pattern of a destructuring assignment.
     inside_assignment: bool,
@@ -918,10 +849,10 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
     ) -> Self {
         let trait_env = db.trait_environment_for_body(owner);
         let table = unify::InferenceTable::new(db, trait_env, resolver.krate(), Some(owner));
-        let types = InternedStandardTypes::new(table.interner());
+        let types = crate::next_solver::default_types(db);
         InferenceContext {
-            result: InferenceResult::new(types.error),
-            return_ty: types.error, // set in collect_* calls
+            result: InferenceResult::new(types.types.error),
+            return_ty: types.types.error, // set in collect_* calls
             types,
             target_features: OnceCell::new(),
             unstable_features: MethodResolutionUnstableFeatures::from_def_map(
@@ -1153,7 +1084,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
             data.type_ref,
             &data.store,
             InferenceTyDiagnosticSource::Signature,
-            LifetimeElisionKind::Elided(self.types.re_static),
+            LifetimeElisionKind::Elided(self.types.regions.statik),
         );
 
         self.return_ty = return_ty;
@@ -1211,7 +1142,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                 );
                 self.process_user_written_ty(return_ty)
             }
-            None => self.types.unit,
+            None => self.types.types.unit,
         };
 
         self.return_coercion = Some(CoerceMany::new(self.return_ty));
@@ -1408,7 +1339,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
     }
 
     fn err_ty(&self) -> Ty<'db> {
-        self.types.error
+        self.types.types.error
     }
 
     pub(crate) fn make_body_lifetime(&mut self, lifetime_ref: LifetimeRefId) -> Region<'db> {
@@ -1573,7 +1504,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
         if let Err(_err) = result {
             // FIXME: Emit diagnostic.
         }
-        result.unwrap_or(self.types.error)
+        result.unwrap_or(self.types.types.error)
     }
 
     fn expr_ty(&self, expr: ExprId) -> Ty<'db> {
@@ -1805,7 +1736,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
                 result
             } else {
                 // FIXME diagnostic
-                (ctx.types.error, None)
+                (ctx.types.types.error, None)
             }
         }
     }

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

@@ -13,7 +13,7 @@ use rustc_type_ir::{
     ClosureArgs, ClosureArgsParts, CoroutineArgs, CoroutineArgsParts, CoroutineClosureArgs,
     CoroutineClosureArgsParts, Interner, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
     TypeVisitor,
-    inherent::{BoundExistentialPredicates, GenericArgs as _, IntoKind, SliceLike, Ty as _},
+    inherent::{BoundExistentialPredicates, GenericArgs as _, IntoKind, Ty as _},
 };
 use tracing::debug;
 
@@ -22,9 +22,8 @@ use crate::{
     db::{InternedClosure, InternedCoroutine},
     infer::{BreakableKind, Diverges, coerce::CoerceMany},
     next_solver::{
-        AliasTy, Binder, BoundRegionKind, BoundVarKind, BoundVarKinds, ClauseKind, DbInterner,
-        ErrorGuaranteed, FnSig, GenericArgs, PolyFnSig, PolyProjectionPredicate, Predicate,
-        PredicateKind, SolverDefId, Ty, TyKind,
+        AliasTy, Binder, ClauseKind, DbInterner, ErrorGuaranteed, FnSig, GenericArgs, PolyFnSig,
+        PolyProjectionPredicate, Predicate, PredicateKind, SolverDefId, Ty, TyKind,
         abi::Safety,
         infer::{
             BoundRegionConversionTime, InferOk, InferResult,
@@ -73,16 +72,17 @@ impl<'db> InferenceContext<'_, 'db> {
 
         let parent_args = GenericArgs::identity_for_item(interner, self.generic_def.into());
         // FIXME: Make this an infer var and infer it later.
-        let tupled_upvars_ty = self.types.unit;
+        let tupled_upvars_ty = self.types.types.unit;
         let (id, ty, resume_yield_tys) = match closure_kind {
             ClosureKind::Coroutine(_) => {
                 let yield_ty = self.table.next_ty_var();
-                let resume_ty = liberated_sig.inputs().get(0).unwrap_or(self.types.unit);
+                let resume_ty =
+                    liberated_sig.inputs().first().copied().unwrap_or(self.types.types.unit);
 
                 // FIXME: Infer the upvars later.
                 let parts = CoroutineArgsParts {
-                    parent_args,
-                    kind_ty: self.types.unit,
+                    parent_args: parent_args.as_slice(),
+                    kind_ty: self.types.types.unit,
                     resume_ty,
                     yield_ty,
                     return_ty: body_ret_ty,
@@ -119,7 +119,7 @@ impl<'db> InferenceContext<'_, 'db> {
                 };
                 // FIXME: Infer the kind later if needed.
                 let parts = ClosureArgsParts {
-                    parent_args,
+                    parent_args: parent_args.as_slice(),
                     closure_kind_ty: Ty::from_closure_kind(
                         interner,
                         expected_kind.unwrap_or(rustc_type_ir::ClosureKind::Fn),
@@ -140,9 +140,9 @@ impl<'db> InferenceContext<'_, 'db> {
                 // async closures always return the type ascribed after the `->` (if present),
                 // and yield `()`.
                 let bound_return_ty = bound_sig.skip_binder().output();
-                let bound_yield_ty = self.types.unit;
+                let bound_yield_ty = self.types.types.unit;
                 // rustc uses a special lang item type for the resume ty. I don't believe this can cause us problems.
-                let resume_ty = self.types.unit;
+                let resume_ty = self.types.types.unit;
 
                 // FIXME: Infer the kind later if needed.
                 let closure_kind_ty = Ty::from_closure_kind(
@@ -155,26 +155,26 @@ impl<'db> InferenceContext<'_, 'db> {
                 let coroutine_captures_by_ref_ty = Ty::new_fn_ptr(
                     interner,
                     Binder::bind_with_vars(
-                        interner.mk_fn_sig([], self.types.unit, false, Safety::Safe, FnAbi::Rust),
-                        BoundVarKinds::new_from_iter(
-                            interner,
-                            [BoundVarKind::Region(BoundRegionKind::ClosureEnv)],
+                        interner.mk_fn_sig(
+                            [],
+                            self.types.types.unit,
+                            false,
+                            Safety::Safe,
+                            FnAbi::Rust,
                         ),
+                        self.types.coroutine_captures_by_ref_bound_var_kinds,
                     ),
                 );
                 let closure_args = CoroutineClosureArgs::new(
                     interner,
                     CoroutineClosureArgsParts {
-                        parent_args,
+                        parent_args: parent_args.as_slice(),
                         closure_kind_ty,
                         signature_parts_ty: Ty::new_fn_ptr(
                             interner,
                             bound_sig.map_bound(|sig| {
                                 interner.mk_fn_sig(
-                                    [
-                                        resume_ty,
-                                        Ty::new_tup_from_iter(interner, sig.inputs().iter()),
-                                    ],
+                                    [resume_ty, Ty::new_tup(interner, sig.inputs())],
                                     Ty::new_tup(interner, &[bound_yield_ty, bound_return_ty]),
                                     sig.c_variadic,
                                     sig.safety,
@@ -195,7 +195,7 @@ impl<'db> InferenceContext<'_, 'db> {
 
         // Now go through the argument patterns
         for (arg_pat, arg_ty) in args.iter().zip(bound_sig.skip_binder().inputs()) {
-            self.infer_top_pat(*arg_pat, arg_ty, None);
+            self.infer_top_pat(*arg_pat, *arg_ty, None);
         }
 
         // FIXME: lift these out into a struct
@@ -668,7 +668,7 @@ impl<'db> InferenceContext<'_, 'db> {
         assert!(!expected_sig.skip_binder().has_vars_bound_above(rustc_type_ir::INNERMOST));
         let bound_sig = expected_sig.map_bound(|sig| {
             self.interner().mk_fn_sig(
-                sig.inputs(),
+                sig.inputs().iter().copied(),
                 sig.output(),
                 sig.c_variadic,
                 Safety::Safe,
@@ -744,9 +744,10 @@ impl<'db> InferenceContext<'_, 'db> {
 
             // The liberated version of this signature should be a subtype
             // of the liberated form of the expectation.
-            for (supplied_ty, expected_ty) in
-                iter::zip(supplied_sig.inputs(), expected_sigs.liberated_sig.inputs())
-            {
+            for (supplied_ty, expected_ty) in iter::zip(
+                supplied_sig.inputs().iter().copied(),
+                expected_sigs.liberated_sig.inputs().iter().copied(),
+            ) {
                 // Check that E' = S'.
                 let cause = ObligationCause::new();
                 let InferOk { value: (), obligations } =
@@ -765,7 +766,8 @@ impl<'db> InferenceContext<'_, 'db> {
 
             let inputs = supplied_sig
                 .inputs()
-                .into_iter()
+                .iter()
+                .copied()
                 .map(|ty| table.infer_ctxt.resolve_vars_if_possible(ty));
 
             expected_sigs.liberated_sig = table.interner().mk_fn_sig(

crates/hir-ty/src/infer/closure/analysis.rs

@@ -289,7 +289,7 @@ impl CapturedItemWithoutTy {
                     BorrowKind::Mut { .. } => Mutability::Mut,
                     _ => Mutability::Not,
                 };
-                Ty::new_ref(ctx.interner(), ctx.types.re_error, ty, m)
+                Ty::new_ref(ctx.interner(), ctx.types.regions.error, ty, m)
             }
         };
         CapturedItem {