Auto merge of #17023 - Veykril:cleanup, r=Veykril

internal: Some cleanup and perf

Author: bors

crates/base-db/src/input.rs

@@ -285,9 +285,9 @@ pub struct CrateData {
 /// For purposes of analysis, crates are anonymous (only names in
 /// `Dependency` matters), this name should only be used for UI.
 pubdisplay_name:Option<CrateDisplayName>,
-pubcfg_options:CfgOptions,
+pubcfg_options:Arc<CfgOptions>,
 /// The cfg options that could be used by the crate
-pubpotential_cfg_options:Option<CfgOptions>,
+pubpotential_cfg_options:Option<Arc<CfgOptions>>,
 pubenv:Env,
 pubdependencies:Vec<Dependency>,
 puborigin:CrateOrigin,
@@ -328,8 +328,8 @@ impl CrateGraph {
 edition:Edition,
 display_name:Option<CrateDisplayName>,
 version:Option<String>,
-cfg_options:CfgOptions,
-potential_cfg_options:Option<CfgOptions>,
+cfg_options:Arc<CfgOptions>,
+potential_cfg_options:Option<Arc<CfgOptions>>,
 env:Env,
 is_proc_macro:bool,
 origin:CrateOrigin,

crates/hir-def/src/data.rs

@@ -737,7 +737,7 @@ impl<'a> AssocItemCollector<'a> {
 &AstIdWithPath::new(file_id, ast_id,Clone::clone(path)),
  ctxt,
  expand_to,
-self.expander.module.krate(),
+self.expander.krate(),
  resolver,
 ){
 Ok(Some(call_id)) => {

crates/hir-def/src/data/adt.rs

@@ -191,8 +191,6 @@ impl StructData {
 let krate = loc.container.krate;
 let item_tree = loc.id.item_tree(db);
 let repr = repr_from_value(db, krate,&item_tree,ModItem::from(loc.id.value).into());
-let cfg_options = db.crate_graph()[krate].cfg_options.clone();
-
 let attrs = item_tree.attrs(db, krate,ModItem::from(loc.id.value).into());
 
 letmut flags = StructFlags::NO_FLAGS;
@@ -219,7 +217,7 @@ impl StructData {
  loc.id.file_id(),
  loc.container.local_id,
 &item_tree,
-&cfg_options,
+&db.crate_graph()[krate].cfg_options,
 &strukt.fields,
 None,
 );
@@ -248,8 +246,6 @@ impl StructData {
 let krate = loc.container.krate;
 let item_tree = loc.id.item_tree(db);
 let repr = repr_from_value(db, krate,&item_tree,ModItem::from(loc.id.value).into());
-let cfg_options = db.crate_graph()[krate].cfg_options.clone();
-
 let attrs = item_tree.attrs(db, krate,ModItem::from(loc.id.value).into());
 letmut flags = StructFlags::NO_FLAGS;
 if attrs.by_key("rustc_has_incoherent_inherent_impls").exists(){
@@ -266,7 +262,7 @@ impl StructData {
  loc.id.file_id(),
  loc.container.local_id,
 &item_tree,
-&cfg_options,
+&db.crate_graph()[krate].cfg_options,
 &union.fields,
 None,
 );
@@ -338,7 +334,6 @@ impl EnumVariantData {
 let container = loc.parent.lookup(db).container;
 let krate = container.krate;
 let item_tree = loc.id.item_tree(db);
-let cfg_options = db.crate_graph()[krate].cfg_options.clone();
 let variant = &item_tree[loc.id.value];
 
 let(var_data, diagnostics) = lower_fields(
@@ -347,7 +342,7 @@ impl EnumVariantData {
  loc.id.file_id(),
  container.local_id,
 &item_tree,
-&cfg_options,
+&db.crate_graph()[krate].cfg_options,
 &variant.fields,
 Some(item_tree[loc.parent.lookup(db).id.value].visibility),
 );

crates/hir-def/src/expander.rs

@@ -11,6 +11,7 @@ use hir_expand::{
 };
 use limit::Limit;
 use syntax::{ast,Parse};
+use triomphe::Arc;
 
 usecrate::{
  attr::Attrs, db::DefDatabase, lower::LowerCtx, path::Path,AsMacroCall,MacroId,ModuleId,
@@ -19,9 +20,8 @@ use crate::{
 
 #[derive(Debug)]
 pubstructExpander{
-cfg_options:CfgOptions,
+cfg_options:Arc<CfgOptions>,
 span_map:OnceCell<SpanMap>,
-krate:CrateId,
 current_file_id:HirFileId,
 pub(crate)module:ModuleId,
 /// `recursion_depth == usize::MAX` indicates that the recursion limit has been reached.
@@ -45,10 +45,13 @@ impl Expander {
  recursion_limit,
 cfg_options: db.crate_graph()[module.krate].cfg_options.clone(),
 span_map:OnceCell::new(),
-krate: module.krate,
 }
 }
 
+pubfnkrate(&self) -> CrateId{
+self.module.krate
+}
+
 pubfnenter_expand<T: ast::AstNode>(
 &mutself,
 db:&dynDefDatabase,
@@ -112,7 +115,7 @@ impl Expander {
 pub(crate)fnparse_attrs(&self,db:&dynDefDatabase,owner:&dyn ast::HasAttrs) -> Attrs{
 Attrs::filter(
  db,
-self.krate,
+self.krate(),
 RawAttrs::new(
  db.upcast(),
  owner,

crates/hir-def/src/generics.rs

@@ -3,13 +3,15 @@
 //! generic parameters. See also the `Generics` type and the `generics_of` query
 //! in rustc.
 
+use std::ops;
+
 use either::Either;
 use hir_expand::{
  name::{AsName,Name},
 ExpandResult,
 };
 use intern::Interned;
-use la_arena::{Arena,Idx};
+use la_arena::Arena;
 use once_cell::unsync::Lazy;
 use stdx::impl_from;
 use syntax::ast::{self,HasGenericParams,HasName,HasTypeBounds};
@@ -23,7 +25,7 @@ use crate::{
  nameres::{DefMap,MacroSubNs},
  type_ref::{ConstRef,LifetimeRef,TypeBound,TypeRef},
 AdtId,ConstParamId,GenericDefId,HasModule,ItemTreeLoc,LifetimeParamId,
-LocalTypeOrConstParamId,Lookup,TypeOrConstParamId,TypeParamId,
+LocalLifetimeParamId,LocalTypeOrConstParamId,Lookup,TypeOrConstParamId,TypeParamId,
 };
 
 /// Data about a generic type parameter (to a function, struct, impl, ...).
@@ -158,6 +160,20 @@ pub struct GenericParams {
 pubwhere_predicates:Box<[WherePredicate]>,
 }
 
+impl ops::Index<LocalTypeOrConstParamId>forGenericParams{
+typeOutput = TypeOrConstParamData;
+fnindex(&self,index:LocalTypeOrConstParamId) -> &TypeOrConstParamData{
+&self.type_or_consts[index]
+}
+}
+
+impl ops::Index<LocalLifetimeParamId>forGenericParams{
+typeOutput = LifetimeParamData;
+fnindex(&self,index:LocalLifetimeParamId) -> &LifetimeParamData{
+&self.lifetimes[index]
+}
+}
+
 /// A single predicate from a where clause, i.e. `where Type: Trait`. Combined
 /// where clauses like `where T: Foo + Bar` are turned into multiple of these.
 /// It might still result in multiple actual predicates though, because of
@@ -199,7 +215,7 @@ impl GenericParamsCollector {
 lower_ctx:&LowerCtx<'_>,
 node:&dynHasGenericParams,
 add_param_attrs:implFnMut(
-Either<Idx<TypeOrConstParamData>,Idx<LifetimeParamData>>,
+Either<LocalTypeOrConstParamId,LocalLifetimeParamId>,
  ast::GenericParam,
 ),
 ){
@@ -227,7 +243,7 @@ impl GenericParamsCollector {
 lower_ctx:&LowerCtx<'_>,
 params: ast::GenericParamList,
 mutadd_param_attrs:implFnMut(
-Either<Idx<TypeOrConstParamData>,Idx<LifetimeParamData>>,
+Either<LocalTypeOrConstParamId,LocalLifetimeParamId>,
  ast::GenericParam,
 ),
 ){
@@ -416,16 +432,16 @@ impl GenericParams {
 }
 
 /// Iterator of type_or_consts field
-pubfniter(
+pubfniter_type_or_consts(
 &self,
-) -> implDoubleEndedIterator<Item = (Idx<TypeOrConstParamData>,&TypeOrConstParamData)>{
+) -> implDoubleEndedIterator<Item = (LocalTypeOrConstParamId,&TypeOrConstParamData)>{
 self.type_or_consts.iter()
 }
 
 /// Iterator of lifetimes field
 pubfniter_lt(
 &self,
-) -> implDoubleEndedIterator<Item = (Idx<LifetimeParamData>,&LifetimeParamData)>{
+) -> implDoubleEndedIterator<Item = (LocalLifetimeParamId,&LifetimeParamData)>{
 self.lifetimes.iter()
 }
 

crates/hir-ty/src/consteval.rs

@@ -77,30 +77,32 @@ pub(crate) fn path_to_const(
 resolver:&Resolver,
 path:&Path,
 mode:ParamLoweringMode,
-args_lazy:implFnOnce() -> Generics,
+args:implFnOnce() -> Option<Generics>,
 debruijn:DebruijnIndex,
 expected_ty:Ty,
 ) -> 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(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
-None => {
-never!(
-"Generic list doesn't contain this param: {:?}, {:?}, {:?}",
- args,
- path,
- p
-);
-returnNone;
+ParamLoweringMode::Variable => {
+let args = args();
+match args.as_ref().and_then(|args| args.type_or_const_param_idx(p.into())){
+Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
+None => {
+never!(
+"Generic list doesn't contain this param: {:?}, {:?}, {:?}",
+ args,
+ path,
+ p
+);
+returnNone;
+}
 }
-},
+}
 };
 Some(ConstData{ ty, value }.intern(Interner))
 }
@@ -285,7 +287,6 @@ pub(crate) fn eval_to_const(
 expr:ExprId,
 mode:ParamLoweringMode,
 ctx:&mutInferenceContext<'_>,
-args:implFnOnce() -> Generics,
 debruijn:DebruijnIndex,
 ) -> Const{
 let db = ctx.db;
@@ -304,7 +305,9 @@ pub(crate) fn eval_to_const(
 }
 ifletExpr::Path(p) = &ctx.body.exprs[expr]{
 let resolver = &ctx.resolver;
-ifletSome(c) = path_to_const(db, resolver, p, mode, args, debruijn, infer[expr].clone()){
+ifletSome(c) =
+path_to_const(db, resolver, p, mode, || ctx.generics(), debruijn, infer[expr].clone())
+{
 return c;
 }
 }

crates/hir-ty/src/display.rs

@@ -453,7 +453,7 @@ impl HirDisplay for Const {
 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];
+let param_data = &generics.params[id.local_id];
 write!(f,"{}", param_data.name().unwrap().display(f.db.upcast()))?;
 Ok(())
 }
@@ -1176,7 +1176,7 @@ impl HirDisplay for Ty {
 TyKind::Placeholder(idx) => {
 let id = from_placeholder_idx(db,*idx);
 let generics = generics(db.upcast(), id.parent);
-let param_data = &generics.params.type_or_consts[id.local_id];
+let param_data = &generics.params[id.local_id];
 match param_data {
 TypeOrConstParamData::TypeParamData(p) => match p.provenance{
 TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {
@@ -1724,7 +1724,7 @@ impl HirDisplay for LifetimeData {
 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];
+let param_data = &generics.params[id.local_id];
 write!(f,"{}", param_data.name.display(f.db.upcast()))?;
 Ok(())
 }

crates/hir-ty/src/infer.rs

@@ -60,7 +60,7 @@ use crate::{
  lower::ImplTraitLoweringMode,
  to_assoc_type_id,
  traits::FnTrait,
- utils::{InTypeConstIdMetadata,UnevaluatedConstEvaluatorFolder},
+ utils::{Generics,InTypeConstIdMetadata,UnevaluatedConstEvaluatorFolder},
 AliasEq,AliasTy,Binders,ClosureId,Const,DomainGoal,GenericArg,Goal,ImplTraitId,
 ImplTraitIdx,InEnvironment,Interner,Lifetime,OpaqueTyId,ProjectionTy,Substitution,
 TraitEnvironment,Ty,TyBuilder,TyExt,
@@ -630,6 +630,10 @@ impl<'a> InferenceContext<'a> {
 }
 }
 
+pub(crate)fngenerics(&self) -> Option<Generics>{
+Some(crate::utils::generics(self.db.upcast(),self.resolver.generic_def()?))
+}
+
 // FIXME: This function should be private in module. It is currently only used in the consteval, since we need
 // `InferenceResult` in the middle of inference. See the fixme comment in `consteval::eval_to_const`. If you
 // used this function for another workaround, mention it here. If you really need this function and believe that

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

@@ -19,10 +19,6 @@ impl CastCheck {
 let expr_ty = table.resolve_ty_shallow(&self.expr_ty);
 let cast_ty = table.resolve_ty_shallow(&self.cast_ty);
 
-if expr_ty.contains_unknown() || cast_ty.contains_unknown(){
-return;
-}
-
 if table.coerce(&expr_ty,&cast_ty).is_ok(){
 return;
 }

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

@@ -26,7 +26,7 @@ use crate::{
  mir::{BorrowKind,MirSpan,MutBorrowKind,ProjectionElem},
  to_chalk_trait_id,
  traits::FnTrait,
- utils::{self, elaborate_clause_supertraits,generics,Generics},
+ utils::{self, elaborate_clause_supertraits,Generics},
 Adjust,Adjustment,AliasEq,AliasTy,Binders,BindingMode,ChalkTraitId,ClosureId,DynTy,
 DynTyExt,FnAbi,FnPointer,FnSig,Interner,OpaqueTy,ProjectionTyExt,Substitution,Ty,
 TyExt,WhereClause,
@@ -331,14 +331,10 @@ impl CapturedItemWithoutTy {
 place:self.place,
 kind:self.kind,
 span:self.span,
-ty:replace_placeholder_with_binder(ctx.db, ctx.owner, ty),
+ty:replace_placeholder_with_binder(ctx, ty),
 };
 
-fnreplace_placeholder_with_binder(
-db:&dynHirDatabase,
-owner:DefWithBodyId,
-ty:Ty,
-) -> Binders<Ty>{
+fnreplace_placeholder_with_binder(ctx:&mutInferenceContext<'_>,ty:Ty) -> Binders<Ty>{
 structFiller<'a>{
 db:&'adynHirDatabase,
 generics:Generics,
@@ -361,7 +357,7 @@ impl CapturedItemWithoutTy {
 outer_binder:DebruijnIndex,
 ) -> Result<chalk_ir::Const<Interner>,Self::Error>{
 let x = from_placeholder_idx(self.db, idx);
-letSome(idx) = self.generics.param_idx(x)else{
+letSome(idx) = self.generics.type_or_const_param_idx(x)else{
 returnErr(());
 };
 Ok(BoundVar::new(outer_binder, idx).to_const(Interner, ty))
@@ -373,18 +369,18 @@ impl CapturedItemWithoutTy {
 outer_binder:DebruijnIndex,
 ) -> std::result::Result<Ty,Self::Error>{
 let x = from_placeholder_idx(self.db, idx);
-letSome(idx) = self.generics.param_idx(x)else{
+letSome(idx) = self.generics.type_or_const_param_idx(x)else{
 returnErr(());
 };
 Ok(BoundVar::new(outer_binder, idx).to_ty(Interner))
 }
 }
-letSome(generic_def) = owner.as_generic_def_id()else{
+letSome(generics) = ctx.generics()else{
 returnBinders::empty(Interner, ty);
 };
-let filler = &mutFiller{ db,generics:generics(db.upcast(), generic_def)};
+let filler = &mutFiller{db: ctx.db, generics};
 let result = ty.clone().try_fold_with(filler,DebruijnIndex::INNERMOST).unwrap_or(ty);
-make_binders(db,&filler.generics, result)
+make_binders(ctx.db,&filler.generics, result)
 }
 }
 }