Rust: Guard library diagnostics

Author: paldepind

rust/codeql-extractor.yml

@@ -88,3 +88,10 @@ options:
       Extract the full source code of dependencies instead of only extracting signatures.
     type: string
     pattern: "^(false|true)$"
+  library_diagnostics:
+    title: Emit dependency library diagnostics
+    description: >
+      Collect and emit detailed parse and macro-expansion diagnostics for dependency libraries.
+      This can substantially increase extraction time.
+    type: string
+    pattern: "^(false|true)$"

rust/extractor/src/config.rs

@@ -73,6 +73,7 @@ pub struct Config {
     pub extra_includes: Vec<PathBuf>,
     pub proc_macro_server: Option<PathBuf>,
     pub extract_dependencies_as_source: bool,
+    pub library_diagnostics: bool,
     pub force_library_mode: bool, // for testing purposes
 }
 

rust/extractor/src/main.rs

@@ -38,14 +38,20 @@ pub mod trap;
 struct Extractor<'a> {
     archiver: &'a Archiver,
     traps: &'a trap::TrapFileProvider,
+    library_diagnostics: bool,
     steps: Vec<ExtractionStep>,
 }
 
 impl<'a> Extractor<'a> {
-    pub fn new(archiver: &'a Archiver, traps: &'a trap::TrapFileProvider) -> Self {
+    pub fn new(
+        archiver: &'a Archiver,
+        traps: &'a trap::TrapFileProvider,
+        library_diagnostics: bool,
+    ) -> Self {
         Self {
             archiver,
             traps,
+            library_diagnostics,
             steps: Vec::new(),
         }
     }
@@ -74,10 +80,13 @@ impl<'a> Extractor<'a> {
             line_index,
             semantics_info.as_ref().ok(),
             source_kind,
+            self.library_diagnostics,
         );
 
-        for err in errors {
-            translator.emit_parse_error(&ast, &err);
+        if translator.detailed_diagnostics_enabled() {
+            for err in errors {
+                translator.emit_parse_error(&ast, &err);
+            }
         }
         let no_location = (LineCol { line: 0, col: 0 }, LineCol { line: 0, col: 0 });
         if let Err(RustAnalyzerNoSemantics { severity, reason }) = semantics_info
@@ -238,7 +247,7 @@ fn main() -> anyhow::Result<()> {
     let archiver = archive::Archiver {
         root: cfg.source_archive_dir.clone(),
     };
-    let mut extractor = Extractor::new(&archiver, &traps);
+    let mut extractor = Extractor::new(&archiver, &traps, cfg.library_diagnostics);
     let files: Vec<PathBuf> = cfg
         .inputs
         .iter()

rust/extractor/src/translate/base.rs

@@ -131,6 +131,7 @@ pub struct Translator<'db> {
     file_id: Option<EditionedFileId>,
     pub semantics: Option<&'db Semantics<'db, RootDatabase>>,
     source_kind: SourceKind,
+    library_diagnostics: bool,
     pub(crate) macro_context_depth: usize,
     diagnostic_count: usize,
     /// When emitting a reconstructed built-in derive expansion, holds the span map of the
@@ -152,6 +153,7 @@ impl<'db> Translator<'db> {
         line_index: LineIndex,
         semantic_info: Option<&FileSemanticInformation<'db>>,
         source_kind: SourceKind,
+        library_diagnostics: bool,
     ) -> Translator<'db> {
         Translator {
             trap,
@@ -161,11 +163,17 @@ impl<'db> Translator<'db> {
             file_id: semantic_info.map(|i| i.file_id),
             semantics: semantic_info.map(|i| i.semantics),
             source_kind,
+            library_diagnostics,
             macro_context_depth: 0,
             diagnostic_count: 0,
             builtin_derive_span_map: None,
         }
     }
+
+    pub fn detailed_diagnostics_enabled(&self) -> bool {
+        self.source_kind == SourceKind::Source || self.library_diagnostics
+    }
+
     fn location(&self, range: TextRange) -> Option<(LineCol, LineCol)> {
         let start = self.line_index.try_line_col(range.start())?;
         let range_end = range.end();
@@ -368,6 +376,9 @@ impl<'db> Translator<'db> {
         node: &impl ast::AstNode,
         expanded: &SyntaxNode,
     ) {
+        if !self.detailed_diagnostics_enabled() {
+            return;
+        }
         let semantics = self.semantics.as_ref().unwrap();
         if let Some(value) = semantics
             .hir_file_for(expanded)
@@ -448,7 +459,7 @@ impl<'db> Translator<'db> {
                     value,
                     &mut self.trap.writer,
                 );
-            } else {
+            } else if self.detailed_diagnostics_enabled() {
                 let range = self.text_range_for_node(mcall);
                 self.emit_parse_error(mcall, &SyntaxError::new(
                     format!(
@@ -463,18 +474,20 @@ impl<'db> Translator<'db> {
             if self.reconstruct_format_args_expansion(mcall, label) {
                 return;
             }
-            // let's not spam warnings if we don't have semantics, we already emitted one
-            let range = self.text_range_for_node(mcall);
-            self.emit_parse_error(
-                mcall,
-                &SyntaxError::new(
-                    format!(
-                        "macro expansion failed for '{}'",
-                        mcall.path().map(|p| p.to_string()).unwrap_or_default()
+            if self.detailed_diagnostics_enabled() {
+                // let's not spam warnings if we don't have semantics, we already emitted one
+                let range = self.text_range_for_node(mcall);
+                self.emit_parse_error(
+                    mcall,
+                    &SyntaxError::new(
+                        format!(
+                            "macro expansion failed for '{}'",
+                            mcall.path().map(|p| p.to_string()).unwrap_or_default()
+                        ),
+                        range.unwrap_or_else(|| TextRange::empty(TextSize::from(0))),
                     ),
-                    range.unwrap_or_else(|| TextRange::empty(TextSize::from(0))),
-                ),
-            );
+                );
+            }
         }
     }
 
@@ -633,7 +646,9 @@ impl<'db> Translator<'db> {
     ) -> Option<Label<generated::MacroItems>> {
         let semantics = self.semantics.unwrap(); // if we are here, we have semantics
         self.emit_macro_expansion_parse_errors(node, &value);
-        if let Some(err) = err {
+        if let Some(err) = err
+            && self.detailed_diagnostics_enabled()
+        {
             let rendered = err.render_to_string(semantics.db);
             self.emit_diagnostic_for_node(
                 node,
@@ -645,7 +660,7 @@ impl<'db> Translator<'db> {
         }
         if let Some(items) = ast::MacroItems::cast(value) {
             self.emit_macro_items(&items)
-        } else {
+        } else if self.detailed_diagnostics_enabled() {
             let message =
                 "attribute or derive macro expansion cannot be cast to MacroItems".to_owned();
             self.emit_diagnostic_for_node(
@@ -656,6 +671,8 @@ impl<'db> Translator<'db> {
                 message,
             );
             None
+        } else {
+            None
         }
     }
 
@@ -768,7 +785,9 @@ impl<'db> Translator<'db> {
         let (parsed, output_span_map) =
             token_tree_to_syntax_node(&output, TopEntryPoint::MacroItems, &mut |_| edition);
         let items = ast::MacroItems::cast(parsed.syntax_node())?;
-        if let Some(err) = err {
+        if let Some(err) = err
+            && self.detailed_diagnostics_enabled()
+        {
             let rendered = err.render_to_string(db);
             self.emit_diagnostic_for_node(
                 adt,