Merge pull request #190 from github/analyze-updates

Updates to `analyze` (and `test`)

Author: Hendrik van Antwerpen

languages/tree-sitter-stack-graphs-typescript/src/stack-graphs.tsg

@@ -2732,7 +2732,7 @@ if none @is_async {
 }
 
 
-;; Variables
+;; Variables / Identifiers
 
 ; x;
 
@@ -2742,6 +2742,8 @@ if none @is_async {
   (for_in_statement ["var" "let" "const"]?@is_def left:(identifier)@name)
   (assignment_expression left:(identifier)@name)
   (augmented_assignment_expression left:(identifier)@name)
+  (asserts (identifier)@name)
+  (type_predicate name:(identifier)@name)
   ; FIXME type_query has its own restricted expression production
   ;       we need to do this for every (identifier) inside a type query
   ;       this cannot be expressed, so we manually unroll three levels here
@@ -2789,6 +2791,8 @@ if none @is_def {
   (for_in_statement ["var" "let" "const"]?@is_def left:(identifier)@name)
   (assignment_expression left:(identifier)@name)
   (augmented_assignment_expression left:(identifier)@name)
+  (asserts (identifier)@name)
+  (type_predicate name:(identifier)@name)
   ; FIXME type_query has its own restricted expression production
   (type_query (identifier)@name)
   (type_query (member_expression object:(identifier)@name))
@@ -4972,9 +4976,6 @@ if none @is_acc {
 )@asserts {
   ; propagate lexical scope
   edge @type.lexical_scope -> @asserts.lexical_scope
-
-  ; type is type of inner
-  edge @asserts.type -> @type.type
 }
 
 
@@ -5119,9 +5120,8 @@ if none @is_acc {
   (_)@type
 )@type_pred {
   ; propagate lexical scope
+  edge @name.lexical_scope -> @type_pred.lexical_scope
   edge @type.lexical_scope -> @type_pred.lexical_scope
-
-  ; FIXME name is a expression reference
 }
 
 

languages/tree-sitter-stack-graphs-typescript/test/expressions/asserts-condition.ts

@@ -0,0 +1,7 @@
+function assert(
+    condition: any,
+): asserts condition {
+//         ^ defined: 2
+}
+
+export {}

languages/tree-sitter-stack-graphs-typescript/test/expressions/asserts-type.ts

@@ -0,0 +1,7 @@
+function assertIsString(
+    val: any
+): asserts val is string {
+//         ^ defined: 2
+}
+
+export {}

tree-sitter-stack-graphs/CHANGELOG.md

@@ -32,6 +32,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - The `--show-ignored` flag of the `test` command has been renamed to `--show-skipped`. Only explicitly skipped test files (with a `.skip` extension) will be shown. Other unsupported files are, such as generated HTML files, are never shown.
 - The `--hide-passing` flag of the `test` command has been renamed to the more common `--quiet`/`-q`.
 - The output of the `test` command has changed to print the test name before the test result, so that it clear which test is currently running.
+- The output of the `test` and `analyze` commands has changed in debug builds to include the run time per file.
+- The `--hide-failure-errors` has been renamed to the more general `--hide-error-details`. The new flag is supported by the `test` and `analyze` commands.
+- The files in directory arguments are now processed in filename order.
 
 ## v0.6.0 -- 2023-01-13
 

tree-sitter-stack-graphs/src/cli/analyze.rs

@@ -59,6 +59,10 @@ pub struct AnalyzeArgs {
     #[clap(long, short = 'v')]
     pub verbose: bool,
 
+    /// Hide failure error details.
+    #[clap(long)]
+    pub hide_error_details: bool,
+
     /// Maximum runtime per file in seconds.
     #[clap(
         long,
@@ -78,6 +82,7 @@ impl AnalyzeArgs {
             source_paths,
             continue_from: None,
             verbose: false,
+            hide_error_details: false,
             max_file_time: None,
             wait_at_start: false,
         }
@@ -93,6 +98,7 @@ impl AnalyzeArgs {
                 let source_root = source_path;
                 for source_entry in WalkDir::new(source_root)
                     .follow_links(true)
+                    .sort_by_file_name()
                     .into_iter()
                     .filter_map(|e| e.ok())
                     .filter(|e| e.file_type().is_file())
@@ -203,7 +209,9 @@ impl AnalyzeArgs {
             Err(LoadError::ParseErrors(parse_errors)) => {
                 let parse_error = map_parse_errors(source_path, &parse_errors, &source, "");
                 file_status.error("parsing failed")?;
-                eprintln!("{}", parse_error);
+                if !self.hide_error_details {
+                    println!("{}", parse_error);
+                }
                 return Ok(());
             }
             Err(LoadError::Cancelled(_)) => {

tree-sitter-stack-graphs/src/cli/test.rs

@@ -90,7 +90,7 @@ pub struct TestArgs {
 
     /// Hide failure error details.
     #[clap(long)]
-    pub hide_failure_errors: bool,
+    pub hide_error_details: bool,
 
     /// Show skipped files in output.
     #[clap(long)]
@@ -153,7 +153,7 @@ impl TestArgs {
         Self {
             test_paths,
             quiet: false,
-            hide_failure_errors: false,
+            hide_error_details: false,
             show_skipped: false,
             save_graph: None,
             save_paths: None,
@@ -169,6 +169,7 @@ impl TestArgs {
                 let test_root = test_path;
                 for test_entry in WalkDir::new(test_root)
                     .follow_links(true)
+                    .sort_by_file_name()
                     .into_iter()
                     .filter_map(|e| e.ok())
                     .filter(|e| e.file_type().is_file())
@@ -336,7 +337,7 @@ impl TestArgs {
                 result.count(),
             ))?;
         }
-        if !success && !self.hide_failure_errors {
+        if !success && !self.hide_error_details {
             for failure in result.failures_iter() {
                 println!("{}", failure);
             }

tree-sitter-stack-graphs/src/cli/util.rs

@@ -13,6 +13,7 @@ use std::io::Write;
 use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
+use std::time::Instant;
 use tree_sitter_graph::parse_error::TreeWithParseErrorVec;
 
 use crate::cli::MAX_PARSE_ERRORS;
@@ -164,6 +165,8 @@ pub struct FileStatusLogger<'a> {
     path: &'a Path,
     verbose: bool,
     path_logged: bool,
+    #[cfg(debug_assertions)]
+    processing_started: Option<Instant>,
 }
 
 impl<'a> FileStatusLogger<'a> {
@@ -172,50 +175,81 @@ impl<'a> FileStatusLogger<'a> {
             path,
             verbose,
             path_logged: false,
+            #[cfg(debug_assertions)]
+            processing_started: None,
         }
     }
 
-    pub fn processing(&mut self) -> Result<(), anyhow::Error> {
-        self.print_path(false)?;
-        Ok(())
+    pub fn processing(&mut self) -> std::io::Result<()> {
+        #[cfg(debug_assertions)]
+        {
+            self.processing_started = Some(Instant::now());
+        }
+        if !self.verbose {
+            return Ok(());
+        }
+        self.print_path();
+        std::io::stdout().flush()
     }
 
-    pub fn ok(&mut self, status: &str) -> Result<(), anyhow::Error> {
-        self.print_path(false)?;
-        if self.verbose {
-            println!("{}", status.green());
-            self.path_logged = false;
+    pub fn ok(&mut self, status: &str) -> std::io::Result<()> {
+        if !self.verbose {
+            return Ok(());
         }
-        Ok(())
+        self.print_path();
+        print!("{}", status.green());
+        #[cfg(debug_assertions)]
+        self.print_processing_time();
+        println!();
+        self.path_logged = false;
+        std::io::stdout().flush()
     }
 
-    pub fn info(&mut self, status: &str) -> Result<(), anyhow::Error> {
-        self.print_path(true)?;
-        println!("{}", status.dimmed());
+    pub fn info(&mut self, status: &str) -> std::io::Result<()> {
+        if !self.verbose {
+            return Ok(());
+        }
+        self.print_path();
+        print!("{}", status.dimmed());
+        #[cfg(debug_assertions)]
+        self.print_processing_time();
+        println!();
         self.path_logged = false;
-        Ok(())
+        std::io::stdout().flush()
     }
 
-    pub fn warn(&mut self, status: &str) -> Result<(), anyhow::Error> {
-        self.print_path(true)?;
-        println!("{}", status.yellow());
+    pub fn warn(&mut self, status: &str) -> std::io::Result<()> {
+        self.print_path();
+        print!("{}", status.yellow());
+        #[cfg(debug_assertions)]
+        self.print_processing_time();
+        println!();
         self.path_logged = false;
-        Ok(())
+        std::io::stdout().flush()
     }
 
-    pub fn error(&mut self, status: &str) -> Result<(), anyhow::Error> {
-        self.print_path(true)?;
-        println!("{}", status.red());
+    pub fn error(&mut self, status: &str) -> std::io::Result<()> {
+        self.print_path();
+        print!("{}", status.red());
+        #[cfg(debug_assertions)]
+        self.print_processing_time();
+        println!();
         self.path_logged = false;
-        Ok(())
+        std::io::stdout().flush()
+    }
+
+    fn print_path(&mut self) {
+        if self.path_logged {
+            return;
+        }
+        print!("{}: ", self.path.display());
+        self.path_logged = true;
     }
 
-    fn print_path(&mut self, force: bool) -> Result<(), anyhow::Error> {
-        if (self.verbose || force) && !self.path_logged {
-            print!("{}: ", self.path.display());
-            std::io::stdout().flush()?;
-            self.path_logged = true;
+    #[cfg(debug_assertions)]
+    fn print_processing_time(&mut self) {
+        if let Some(processing_started) = self.processing_started {
+            print!(" [{:.2} s]", processing_started.elapsed().as_secs_f64());
         }
-        Ok(())
     }
 }