internal: A bunch of cleanups and micro-optimizations

crates/hir-def/src/expr_store/lower/generics.rs

@@ -86,10 +86,13 @@ impl GenericParamsCollector {
 
     pub(crate) fn finish(self) -> GenericParams {
         let Self { mut lifetimes, mut type_or_consts, where_predicates, parent: _ } = self;
+        let early_bound_lifetimes_len =
+            lifetimes.iter().filter(|(_, lt)| lt.is_early_bound()).count();
 
         lifetimes.shrink_to_fit();
         type_or_consts.shrink_to_fit();
         GenericParams {
+            early_bound_lifetimes_len,
             type_or_consts,
             lifetimes,
             where_predicates: where_predicates.into_boxed_slice(),

crates/hir-def/src/hir/generics.rs

@@ -44,9 +44,15 @@ pub enum LifetimeBoundType {
 }
 
 impl LifetimeParamData {
+    #[inline]
     pub fn is_late_bound(&self) -> bool {
         self.bound_type == LifetimeBoundType::LateBound
     }
+
+    #[inline]
+    pub fn is_early_bound(&self) -> bool {
+        self.bound_type == LifetimeBoundType::EarlyBound
+    }
 }
 
 /// Data about a generic const parameter (to a function, struct, impl, ...).
@@ -164,6 +170,7 @@ pub struct GenericParams {
     pub(crate) type_or_consts: Arena<TypeOrConstParamData>,
     pub(crate) lifetimes: Arena<LifetimeParamData>,
     pub(crate) where_predicates: Box<[WherePredicate]>,
+    pub(crate) early_bound_lifetimes_len: usize,
 }
 
 impl ops::Index<LocalTypeOrConstParamId> for GenericParams {
@@ -194,6 +201,7 @@ static EMPTY: LazyLock<GenericParams> = LazyLock::new(|| GenericParams {
     type_or_consts: Arena::default(),
     lifetimes: Arena::default(),
     where_predicates: Box::default(),
+    early_bound_lifetimes_len: 0,
 });
 
 impl GenericParams {
@@ -304,14 +312,24 @@ impl GenericParams {
         self.type_or_consts.len() + self.lifetimes.len()
     }
 
+    #[inline]
+    pub fn len_no_late(&self) -> usize {
+        self.type_or_consts.len() + self.early_bound_lifetimes_len
+    }
+
     #[inline]
     pub fn len_lifetimes(&self) -> usize {
-        self.lifetimes.len() - self.len_late_bound_lifetimes()
+        self.lifetimes.len()
+    }
+
+    #[inline]
+    pub fn len_early_bound_lifetimes(&self) -> usize {
+        self.early_bound_lifetimes_len
     }
 
     #[inline]
     pub fn len_late_bound_lifetimes(&self) -> usize {
-        self.lifetimes.iter().filter(|(_, p)| p.bound_type == LifetimeBoundType::LateBound).count()
+        self.len_lifetimes() - self.len_early_bound_lifetimes()
     }
 
     #[inline]

crates/hir-ty/src/builtin_derive.rs

@@ -179,12 +179,12 @@ pub fn predicates(db: &dyn HirDatabase, impl_: BuiltinDeriveImplId) -> GenericPr
             simple_trait_predicates(interner, loc, generic_params, adt_predicates, trait_id)
         }
         BuiltinDeriveImplTrait::Reborrow => {
-            explicit_own_predicates(interner, adt_predicates.own_explicit_predicates())
+            explicit_own_predicates(adt_predicates.own_explicit_predicates())
         }
         BuiltinDeriveImplTrait::Default => {
             if matches!(loc.adt, AdtId::EnumId(_)) {
                 // Enums don't have extra bounds.
-                explicit_own_predicates(interner, adt_predicates.own_explicit_predicates())
+                explicit_own_predicates(adt_predicates.own_explicit_predicates())
             } else {
                 simple_trait_predicates(interner, loc, generic_params, adt_predicates, trait_id)
             }
@@ -218,7 +218,6 @@ pub fn predicates(db: &dyn HirDatabase, impl_: BuiltinDeriveImplId) -> GenericPr
             });
             GenericPredicates::from_explicit_own_predicates(StoredEarlyBinder::bind(
                 Clauses::new_from_iter(
-                    interner,
                     adt_predicates
                         .explicit_predicates()
                         .iter_identity()
@@ -233,11 +232,10 @@ pub fn predicates(db: &dyn HirDatabase, impl_: BuiltinDeriveImplId) -> GenericPr
 }
 
 fn explicit_own_predicates<'db>(
-    interner: DbInterner<'db>,
     predicates: EarlyBinder<'db, impl Iterator<Item = Clause<'db>>>,
 ) -> GenericPredicates {
     GenericPredicates::from_explicit_own_predicates(StoredEarlyBinder::bind(
-        Clauses::new_from_iter(interner, predicates.skip_binder()).store(),
+        Clauses::new_from_iter(predicates.skip_binder()).store(),
     ))
 }
 
@@ -292,8 +290,8 @@ fn simple_trait_predicates<'db>(
                 parent: loc.adt.into(),
                 local_id: param_idx,
             });
-            let param_idx =
-                param_idx.into_raw().into_u32() + (generic_params.len_lifetimes() as u32);
+            let param_idx = param_idx.into_raw().into_u32()
+                + (generic_params.len_early_bound_lifetimes() as u32);
             let param_ty = Ty::new_param(interner, param_id, param_idx);
             let trait_args = trait_args(loc.trait_, param_ty);
             let trait_ref = TraitRef::new_from_args(interner, trait_id.into(), trait_args);
@@ -329,7 +327,6 @@ fn simple_trait_predicates<'db>(
     }
     GenericPredicates::from_explicit_own_predicates(StoredEarlyBinder::bind(
         Clauses::new_from_iter(
-            interner,
             adt_predicates
                 .explicit_predicates()
                 .iter_identity()
@@ -413,7 +410,7 @@ fn coerce_pointee_params<'db>(
         local_id: pointee_param,
     });
     let pointee_param_idx =
-        pointee_param.into_raw().into_u32() + (generic_params.len_lifetimes() as u32);
+        pointee_param.into_raw().into_u32() + (generic_params.len_early_bound_lifetimes() as u32);
     let new_param_idx = generic_params.len() as u32;
     let new_param_id = coerce_pointee_new_type_param(trait_id);
     let new_param_ty = Ty::new_param(interner, new_param_id, new_param_idx);

crates/hir-ty/src/consteval.rs

@@ -125,7 +125,6 @@ fn intern_const_ref<'db>(
         {
             let u8_values = &interner.default_types().consts.u8_values;
             ValTreeKind::Branch(Consts::new_from_iter(
-                interner,
                 value.as_str().as_bytes().iter().map(|&byte| u8_values[usize::from(byte)]),
             ))
         }

crates/hir-ty/src/dyn_compatibility.rs

@@ -454,7 +454,6 @@ fn receiver_is_dispatchable<'db>(
 
         ParamEnv {
             clauses: Clauses::new_from_iter(
-                interner,
                 generic_predicates
                     .iter_identity()
                     .map(Unnormalized::skip_norm_wip)

crates/hir-ty/src/generics.rs

@@ -69,15 +69,11 @@ impl<'db> SingleGenerics<'db> {
     }
 
     pub(crate) fn len_lifetimes(&self) -> usize {
-        self.params.len_lifetimes()
+        self.params.len_early_bound_lifetimes()
     }
 
     pub(crate) fn len(&self, consider_late_bound: bool) -> usize {
-        if consider_late_bound {
-            self.params.len()
-        } else {
-            self.params.len() - self.params.len_late_bound_lifetimes()
-        }
+        if consider_late_bound { self.params.len() } else { self.params.len_no_late() }
     }
 
     fn iter_lifetimes(&self) -> impl Iterator<Item = (LifetimeParamId, &'db LifetimeParamData)> {
@@ -269,7 +265,7 @@ impl<'db> Generics<'db> {
         let parent_total = self.len_parent();
 
         let owner = self.owner();
-        let lifetimes = owner.params.len_lifetimes();
+        let lifetimes = owner.params.len_early_bound_lifetimes();
 
         let mut has_self_param = false;
         let mut non_impl_trait_type_params = 0;

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

@@ -345,28 +345,26 @@ impl<'db> CastCheck<'db> {
                         // We also need to skip auto traits to emit an FCW and not an error.
                         let src_obj = Ty::new_dynamic(
                             ctx.interner(),
-                            BoundExistentialPredicates::new_from_iter(
-                                ctx.interner(),
-                                src_tty.iter().filter(|pred| {
+                            BoundExistentialPredicates::new_from_iter(src_tty.iter().filter(
+                                |pred| {
                                     !matches!(
                                         pred.skip_binder(),
                                         ExistentialPredicate::AutoTrait(_)
                                     )
-                                }),
-                            ),
+                                },
+                            )),
                             Region::new_erased(ctx.interner()),
                         );
                         let dst_obj = Ty::new_dynamic(
                             ctx.interner(),
-                            BoundExistentialPredicates::new_from_iter(
-                                ctx.interner(),
-                                dst_tty.iter().filter(|pred| {
+                            BoundExistentialPredicates::new_from_iter(dst_tty.iter().filter(
+                                |pred| {
                                     !matches!(
                                         pred.skip_binder(),
                                         ExistentialPredicate::AutoTrait(_)
                                     )
-                                }),
-                            ),
+                                },
+                            )),
                             Region::new_erased(ctx.interner()),
                         );
 

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

@@ -1120,7 +1120,7 @@ impl<'db> InferenceContext<'db> {
         let element_tys_iter = (0..max_len).map(|i| {
             self.table.next_ty_var(elements.get(i).copied().map(Span::PatId).unwrap_or(Span::Dummy))
         });
-        let element_tys = Tys::new_from_iter(interner, element_tys_iter);
+        let element_tys = Tys::new_from_iter(element_tys_iter);
         let pat_ty = Ty::new(interner, TyKind::Tuple(element_tys));
         if self.demand_eqtype(pat.into(), expected, pat_ty).is_err() {
             let expected = if let TyKind::Tuple(tys) =

crates/hir-ty/src/lower.rs

@@ -247,7 +247,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         let in_binders = DebruijnIndex::ZERO;
         let interner = DbInterner::new_with(db, resolver.krate());
         let bound_vars =
-            vec![(Vec::new(), TyLoweringContext::bound_vars(db, interner, generic_def, generics))];
+            vec![(Vec::new(), TyLoweringContext::bound_vars(db, generic_def, generics))];
         Self {
             db,
             // Can provide no block since we don't use it for trait solving.
@@ -374,12 +374,10 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
     }
 
     fn push_bound_vars(&mut self, binder: &[Name]) {
-        let bound_vars = BoundVarKinds::new_from_iter(
-            self.interner,
-            binder.iter().map(|_| {
+        let bound_vars =
+            BoundVarKinds::new_from_iter(binder.iter().map(|_| {
                 BoundVariableKind::Region(BoundRegionKind::Named(self.generic_def.into()))
-            }),
-        );
+            }));
         self.bound_vars.push((binder.to_vec(), bound_vars));
     }
 
@@ -393,7 +391,6 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
 
     fn bound_vars(
         db: &'db dyn HirDatabase,
-        interner: DbInterner<'db>,
         def: GenericDefId,
         generic: &'a OnceCell<Generics<'db>>,
     ) -> BoundVarKinds<'db> {
@@ -410,7 +407,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             }
         });
 
-        BoundVarKinds::new_from_iter(interner, args)
+        BoundVarKinds::new_from_iter(args)
     }
 
     fn take_defined_opaques(&mut self) -> Option<Box<Arena<ImplTrait>>> {
@@ -737,7 +734,6 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             hir_def::hir::Pat::NotNull => rustc_type_ir::PatternKind::NotNull,
             hir_def::hir::Pat::Or(ref pats) => rustc_type_ir::PatternKind::Or(
                 PatList::new_from_iter(
-                    self.interner,
                     pats.iter().map(|&pat| self.lower_pattern_type(pat, ty).ok_or(())),
                 )
                 .ok()?,
@@ -1263,7 +1259,6 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
 
             // N.b. principal, projections, auto traits
             Some(BoundExistentialPredicates::new_from_iter(
-                interner,
                 principal.into_iter().chain(projections).chain(auto_traits),
             ))
         };
@@ -2491,7 +2486,7 @@ pub(crate) fn param_env_from_predicates<'db>(
         interner,
         predicates.all_predicates().iter_identity().map(Unnormalized::skip_norm_wip),
     );
-    let clauses = Clauses::new_from_iter(interner, clauses);
+    let clauses = Clauses::new_from_iter(clauses);
 
     // FIXME: We should normalize projections here, like rustc does.
     ParamEnv { clauses }
@@ -2852,11 +2847,11 @@ pub(crate) fn fn_sig_for_fn<'db>(
     };
     let impl_traits = ctx_ret.take_defined_opaques();
 
-    let inputs_and_output = Tys::new_from_iter(interner, params.chain(Some(ret)));
+    let inputs_and_output = Tys::new_from_iter(params.chain(Some(ret)));
     ctx_params.diagnostics.extend(ctx_ret.diagnostics);
     ctx_params.defined_anon_consts.extend(ctx_ret.defined_anon_consts);
 
-    let binder = TyLoweringContext::bound_vars(db, interner, def.into(), &generics);
+    let binder = TyLoweringContext::bound_vars(db, def.into(), &generics);
     let result = StoredEarlyBinder::bind(StoredPolyFnSig::new(Binder::bind_with_vars(
         FnSig {
             inputs_and_output,
@@ -2887,8 +2882,7 @@ fn ctor_signature(
     let params = field_tys.iter().map(|(_, field)| field.ty().skip_binder());
     let ret = type_for_adt(db, adt).skip_binder();
 
-    let inputs_and_output =
-        Tys::new_from_iter(DbInterner::new_no_crate(db), params.chain(Some(ret)));
+    let inputs_and_output = Tys::new_from_iter(params.chain(Some(ret)));
     StoredEarlyBinder::bind(StoredPolyFnSig::new(Binder::dummy(FnSig {
         fn_sig_kind: FnSigKind::new(ExternAbi::Rust, Safety::Safe, false),
         inputs_and_output,

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

@@ -214,7 +214,6 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                                     span,
                                 );
                                 let args = GenericArgs::new_from_iter(
-                                    self.ctx.interner,
                                     trait_ref
                                         .args
                                         .iter()
@@ -544,7 +543,6 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
         let substs = self.substs_from_path_segment(assoc_type.into(), infer_args, None, true, span);
 
         let substs = GenericArgs::new_from_iter(
-            interner,
             trait_args.iter().chain(substs.iter().skip(trait_args.len())),
         );
 
@@ -928,7 +926,6 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                         )
                     });
                 let args = GenericArgs::new_from_iter(
-                    interner,
                     super_trait_args.iter().chain(args.iter().skip(super_trait_args.len())),
                 );
                 let projection_term = AliasTerm::new_from_args(

crates/hir-ty/src/method_resolution.rs

@@ -450,10 +450,7 @@ pub(crate) fn lookup_impl_method_query<'db>(
 
     (
         impl_fn,
-        GenericArgs::new_from_iter(
-            interner,
-            impl_subst.iter().chain(fn_subst.iter().skip(trait_params)),
-        ),
+        GenericArgs::new_from_iter(impl_subst.iter().chain(fn_subst.iter().skip(trait_params))),
     )
 }