Generally optimize diagnostics performance

Author: Veykril

crates/base-db/src/lib.rs

@@ -45,7 +45,7 @@ pub trait Upcast<T: ?Sized> {
 
 pubconstDEFAULT_FILE_TEXT_LRU_CAP:usize = 16;
 pubconstDEFAULT_PARSE_LRU_CAP:usize = 128;
-pubconstDEFAULT_BORROWCK_LRU_CAP:usize = 1024;
+pubconstDEFAULT_BORROWCK_LRU_CAP:usize = 2024;
 
 pubtraitFileLoader{
 /// Text of the file.

crates/hir-def/src/data.rs

@@ -510,6 +510,7 @@ pub struct ConstData {
 pubtype_ref:Interned<TypeRef>,
 pubvisibility:RawVisibility,
 pubrustc_allow_incoherent_impl:bool,
+pubhas_body:bool,
 }
 
 implConstData{
@@ -533,6 +534,7 @@ impl ConstData {
 type_ref: konst.type_ref.clone(),
  visibility,
  rustc_allow_incoherent_impl,
+has_body: konst.has_body,
 })
 }
 }

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

@@ -26,8 +26,7 @@ use crate::{
  tt::{Delimiter,DelimiterKind,Leaf,Subtree,TokenTree},
  type_ref::TypeRef,
  visibility::RawVisibility,
-AdtId,EnumId,EnumVariantId,LocalFieldId,LocalModuleId,Lookup,StructId,UnionId,
-VariantId,
+EnumId,EnumVariantId,LocalFieldId,LocalModuleId,Lookup,StructId,UnionId,VariantId,
 };
 
 /// Note that we use `StructData` for unions as well!
@@ -380,6 +379,7 @@ impl VariantData {
 }
 }
 
+#[allow(clippy::self_named_constructors)]
 pub(crate)fnvariant_data(db:&dynDefDatabase,id:VariantId) -> Arc<VariantData>{
 match id {
 VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),

crates/hir-def/src/db.rs

@@ -22,13 +22,13 @@ use crate::{
  lang_item::{self,LangItem,LangItemTarget,LangItems},
  nameres::{diagnostics::DefDiagnostics,DefMap},
  visibility::{self,Visibility},
-AdtId,AttrDefId,BlockId,BlockLoc,ConstBlockId,ConstBlockLoc,ConstId,ConstLoc,
-DefWithBodyId,EnumId,EnumLoc,EnumVariantId,EnumVariantLoc,ExternBlockId,ExternBlockLoc,
-ExternCrateId,ExternCrateLoc,FunctionId,FunctionLoc,GenericDefId,ImplId,ImplLoc,
-InTypeConstId,InTypeConstLoc,LocalFieldId,Macro2Id,Macro2Loc,MacroId,MacroRulesId,
-MacroRulesLoc,MacroRulesLocFlags,ProcMacroId,ProcMacroLoc,StaticId,StaticLoc,StructId,
-StructLoc,TraitAliasId,TraitAliasLoc,TraitId,TraitLoc,TypeAliasId,TypeAliasLoc,UnionId,
-UnionLoc,UseId,UseLoc,VariantId,
+AttrDefId,BlockId,BlockLoc,ConstBlockId,ConstBlockLoc,ConstId,ConstLoc,DefWithBodyId,
+EnumId,EnumLoc,EnumVariantId,EnumVariantLoc,ExternBlockId,ExternBlockLoc,ExternCrateId,
+ExternCrateLoc,FunctionId,FunctionLoc,GenericDefId,ImplId,ImplLoc,InTypeConstId,
+InTypeConstLoc,LocalFieldId,Macro2Id,Macro2Loc,MacroId,MacroRulesId,MacroRulesLoc,
+MacroRulesLocFlags,ProcMacroId,ProcMacroLoc,StaticId,StaticLoc,StructId,StructLoc,
+TraitAliasId,TraitAliasLoc,TraitId,TraitLoc,TypeAliasId,TypeAliasLoc,UnionId,UnionLoc,
+UseId,UseLoc,VariantId,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]

crates/hir-def/src/item_tree.rs

@@ -716,6 +716,7 @@ pub struct Const {
 pubvisibility:RawVisibilityId,
 pubtype_ref:Interned<TypeRef>,
 pubast_id:FileAstId<ast::Const>,
+pubhas_body:bool,
 }
 
 #[derive(Debug,Clone,Eq,PartialEq)]

crates/hir-def/src/item_tree/lower.rs

@@ -446,7 +446,7 @@ impl<'a> Ctx<'a> {
 let type_ref = self.lower_type_ref_opt(konst.ty());
 let visibility = self.lower_visibility(konst);
 let ast_id = self.source_ast_id_map.ast_id(konst);
-let res = Const{ name, visibility, type_ref, ast_id };
+let res = Const{ name, visibility, type_ref, ast_id,has_body: konst.body().is_some()};
 id(self.data().consts.alloc(res))
 }
 

crates/hir-def/src/item_tree/pretty.rs

@@ -357,7 +357,7 @@ impl Printer<'_> {
 wln!(self,"}}");
 }
 ModItem::Const(it) => {
-letConst{ name, visibility, type_ref, ast_id } = &self.tree[it];
+letConst{ name, visibility, type_ref, ast_id,has_body: _} = &self.tree[it];
 self.print_ast_id(ast_id.erase());
 self.print_visibility(*visibility);
 w!(self,"const ");

crates/hir-ty/src/diagnostics/decl_check.rs

@@ -43,7 +43,7 @@ mod allow {
 }
 
 pubfnincorrect_case(db:&dynHirDatabase,owner:ModuleDefId) -> Vec<IncorrectCase>{
-let _p = tracing::span!(tracing::Level::INFO,"validate_module_item").entered();
+let _p = tracing::span!(tracing::Level::INFO,"incorrect_case").entered();
 letmut validator = DeclValidator::new(db);
  validator.validate_item(owner);
  validator.sink

crates/hir-ty/src/diagnostics/expr.rs

@@ -191,45 +191,45 @@ impl ExprValidator {
 let pattern_arena = Arena::new();
 letmut m_arms = Vec::with_capacity(arms.len());
 letmut has_lowering_errors = false;
+// Note: Skipping the entire diagnostic rather than just not including a faulty match arm is
+// preferred to avoid the chance of false positives.
 for arm in arms {
-ifletSome(pat_ty) = self.infer.type_of_pat.get(arm.pat){
-// We only include patterns whose type matches the type
-// of the scrutinee 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 scrutinee expression type if
-// necessary.
-//
-// FIXME we should use the type checker for this.
-if(pat_ty == scrut_ty
- || scrut_ty
-.as_reference()
-.map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
-.unwrap_or(false))
- && types_of_subpatterns_do_match(arm.pat,&self.body,&self.infer)
-{
-// If we had a NotUsefulMatchArm diagnostic, we could
-// check the usefulness of each pattern as we added it
-// to the matrix here.
-let pat = self.lower_pattern(&cx, arm.pat, db,&mut has_lowering_errors);
-let m_arm = pat_analysis::MatchArm{
-pat: pattern_arena.alloc(pat),
-has_guard: arm.guard.is_some(),
-arm_data:(),
-};
- m_arms.push(m_arm);
-if !has_lowering_errors {
-continue;
-}
+letSome(pat_ty) = self.infer.type_of_pat.get(arm.pat)else{
+return;
+};
+
+// We only include patterns whose type matches the type
+// of the scrutinee 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 scrutinee expression type if
+// necessary.
+//
+// FIXME we should use the type checker for this.
+if(pat_ty == scrut_ty
+ || scrut_ty
+.as_reference()
+.map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
+.unwrap_or(false))
+ && types_of_subpatterns_do_match(arm.pat,&self.body,&self.infer)
+{
+// If we had a NotUsefulMatchArm diagnostic, we could
+// check the usefulness of each pattern as we added it
+// to the matrix here.
+let pat = self.lower_pattern(&cx, arm.pat, db,&mut has_lowering_errors);
+let m_arm = pat_analysis::MatchArm{
+pat: pattern_arena.alloc(pat),
+has_guard: arm.guard.is_some(),
+arm_data:(),
+};
+ 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.
+// If the pattern type doesn't fit the match expression, we skip this diagnostic.
  cov_mark::hit!(validate_match_bailed_out);
 return;
 }
@@ -534,8 +534,16 @@ fn types_of_subpatterns_do_match(pat: PatId, body: &Body, infer: &InferenceResul
 fnwalk(pat:PatId,body:&Body,infer:&InferenceResult,has_type_mismatches:&mutbool){
 match infer.type_mismatch_for_pat(pat){
 Some(_) => *has_type_mismatches = true,
+Noneif*has_type_mismatches => (),
 None => {
- body[pat].walk_child_pats(|subpat| walk(subpat, body, infer, has_type_mismatches))
+let pat = &body[pat];
+ifletPat::ConstBlock(expr) | Pat::Lit(expr) = *pat {
+*has_type_mismatches |= infer.type_mismatch_for_expr(expr).is_some();
+if*has_type_mismatches {
+return;
+}
+}
+ pat.walk_child_pats(|subpat| walk(subpat, body, infer, has_type_mismatches))
 }
 }
 }

crates/hir-ty/src/diagnostics/unsafe_check.rs

@@ -4,7 +4,7 @@
 use hir_def::{
  body::Body,
  hir::{Expr,ExprId,UnaryOp},
- resolver::{resolver_for_expr,ResolveValueResult,ValueNs},
+ resolver::{resolver_for_expr,ResolveValueResult,Resolver,ValueNs},
 DefWithBodyId,
 };
 
@@ -13,9 +13,9 @@ use crate::{
 };
 
 pubfnmissing_unsafe(db:&dynHirDatabase,def:DefWithBodyId) -> Vec<ExprId>{
-let infer = db.infer(def);
-letmut res = Vec::new();
+let _p = tracing::span!(tracing::Level::INFO,"missing_unsafe",);
 
+letmut res = Vec::new();
 let is_unsafe = match def {
 DefWithBodyId::FunctionId(it) => db.function_data(it).has_unsafe_kw(),
 DefWithBodyId::StaticId(_)
@@ -28,6 +28,7 @@ pub fn missing_unsafe(db: &dyn HirDatabase, def: DefWithBodyId) -> Vec<ExprId> {
 }
 
 let body = db.body(def);
+let infer = db.infer(def);
 unsafe_expressions(db,&infer, def,&body, body.body_expr,&mut |expr| {
 if !expr.inside_unsafe_block{
  res.push(expr.expr);
@@ -51,14 +52,24 @@ pub fn unsafe_expressions(
 current:ExprId,
 unsafe_expr_cb:&mutdynFnMut(UnsafeExpr),
 ){
-walk_unsafe(db, infer, def, body, current,false, unsafe_expr_cb)
+walk_unsafe(
+ db,
+ infer,
+ body,
+&mutresolver_for_expr(db.upcast(), def, current),
+ def,
+ current,
+false,
+ unsafe_expr_cb,
+)
 }
 
 fnwalk_unsafe(
 db:&dynHirDatabase,
 infer:&InferenceResult,
-def:DefWithBodyId,
 body:&Body,
+resolver:&mutResolver,
+def:DefWithBodyId,
 current:ExprId,
 inside_unsafe_block:bool,
 unsafe_expr_cb:&mutdynFnMut(UnsafeExpr),
@@ -73,13 +84,14 @@ fn walk_unsafe(
 }
 }
 Expr::Path(path) => {
-letresolver = resolver_for_expr(db.upcast(), def, current);
+letg = resolver.update_to_inner_scope(db.upcast(), def, current);
 let value_or_partial = resolver.resolve_path_in_value_ns(db.upcast(), path);
 ifletSome(ResolveValueResult::ValueNs(ValueNs::StaticId(id), _)) = value_or_partial {
 if db.static_data(id).mutable{
 unsafe_expr_cb(UnsafeExpr{expr: current, inside_unsafe_block });
 }
 }
+ resolver.reset_to_guard(g);
 }
 Expr::MethodCall{ .. } => {
 if infer
@@ -97,13 +109,13 @@ fn walk_unsafe(
 }
 Expr::Unsafe{ .. } => {
 return expr.walk_child_exprs(|child| {
-walk_unsafe(db, infer,def, body, child,true, unsafe_expr_cb);
+walk_unsafe(db, infer,body, resolver, def, child,true, unsafe_expr_cb);
 });
 }
  _ => {}
 }
 
  expr.walk_child_exprs(|child| {
-walk_unsafe(db, infer,def, body, child, inside_unsafe_block, unsafe_expr_cb);
+walk_unsafe(db, infer,body, resolver, def, child, inside_unsafe_block, unsafe_expr_cb);
 });
 }