feat: pass paths in globals

Author: nohehf

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

@@ -13,7 +13,7 @@
 ;; ^^^^^^^^^^^^^^^^
 
 global FILE_PATH
-global ROOT_PATH
+global ROOT_PATH = ""
 global ROOT_NODE
 global JUMP_TO_SCOPE_NODE
 

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

@@ -42,6 +42,7 @@ use crate::BuildError;
 use crate::CancelAfterDuration;
 use crate::CancellationFlag;
 use crate::NoCancellation;
+use crate::{FILE_PATH_VAR, ROOT_PATH_VAR};
 
 #[derive(Args)]
 pub struct IndexArgs {
@@ -430,17 +431,18 @@ impl<'a> Indexer<'a> {
         let relative_source_path = source_path.strip_prefix(source_root).unwrap();
         // here the file should also have stripped the source_root from its path
         if let Some(lc) = lcs.primary {
-            let globals = Variables::new();
+            let mut globals = Variables::new();
+
+            globals
+                .add(FILE_PATH_VAR.into(), source_path.to_str().unwrap().into())
+                .expect("failed to add file path variable");
+
+            globals
+                .add(ROOT_PATH_VAR.into(), source_root.to_str().unwrap().into())
+                .expect("failed to add root path variable");
+
             lc.sgl
-                .build_stack_graph_into(
-                    graph,
-                    file,
-                    source,
-                    source_path,
-                    source_root,
-                    &globals,
-                    cancellation_flag,
-                )
+                .build_stack_graph_into(graph, file, source, &globals, cancellation_flag)
                 .map_err(|inner| BuildErrorWithSource {
                     inner,
                     source_path: source_path.to_path_buf(),

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

@@ -43,6 +43,7 @@ use crate::test::Test;
 use crate::test::TestResult;
 use crate::CancelAfterDuration;
 use crate::CancellationFlag;
+use crate::FILE_PATH_VAR;
 
 #[derive(Args)]
 #[clap(after_help = r#"PATH SPECIFICATIONS:
@@ -316,13 +317,20 @@ impl TestArgs {
                 &mut Some(test_fragment.source.as_ref()),
             )? {
                 globals.clear();
+
+                // Add FILE_PATH to variables
+                globals
+                    .add(
+                        FILE_PATH_VAR.into(),
+                        test_fragment.path.to_str().unwrap().into(),
+                    )
+                    .expect("failed to add file path variable");
+
                 test_fragment.add_globals_to(&mut globals);
                 lc.sgl.build_stack_graph_into(
                     &mut test.graph,
                     test_fragment.file,
                     &test_fragment.source,
-                    &test_fragment.path,
-                    &test_fragment.root_path,
                     &globals,
                     cancellation_flag.as_ref(),
                 )

tree-sitter-stack-graphs/src/lib.rs

@@ -558,12 +558,10 @@ impl StackGraphLanguage {
         stack_graph: &'a mut StackGraph,
         file: Handle<File>,
         source: &'a str,
-        source_path: &Path,
-        source_root: &Path,
         globals: &'a Variables<'a>,
         cancellation_flag: &'a dyn CancellationFlag,
     ) -> Result<(), BuildError> {
-        self.builder_into_stack_graph(stack_graph, file, source, source_path, source_root)
+        self.builder_into_stack_graph(stack_graph, file, source)
             .build(globals, cancellation_flag)
     }
 
@@ -576,10 +574,8 @@ impl StackGraphLanguage {
         stack_graph: &'a mut StackGraph,
         file: Handle<File>,
         source: &'a str,
-        source_path: &'a Path,
-        source_root: &'a Path,
     ) -> Builder<'a> {
-        Builder::new(self, stack_graph, file, source, source_path, source_root)
+        Builder::new(self, stack_graph, file, source)
     }
 }
 
@@ -588,8 +584,6 @@ pub struct Builder<'a> {
     stack_graph: &'a mut StackGraph,
     file: Handle<File>,
     source: &'a str,
-    source_path: &'a Path,
-    source_root: &'a Path,
     graph: Graph<'a>,
     remapped_nodes: HashMap<usize, NodeID>,
     injected_node_count: usize,
@@ -602,17 +596,13 @@ impl<'a> Builder<'a> {
         stack_graph: &'a mut StackGraph,
         file: Handle<File>,
         source: &'a str,
-        source_path: &'a Path,
-        source_root: &'a Path,
     ) -> Self {
         let span_calculator = SpanCalculator::new(source);
         Builder {
             sgl,
             stack_graph,
             file,
             source,
-            source_path,
-            source_root,
             graph: Graph::new(),
             remapped_nodes: HashMap::new(),
             injected_node_count: 0,
@@ -659,19 +649,10 @@ impl<'a> Builder<'a> {
             .add(JUMP_TO_SCOPE_NODE_VAR.into(), jump_to_scope_node.into())
             .expect("Failed to set JUMP_TO_SCOPE_NODE");
 
-        if globals.get(&FILE_PATH_VAR.into()).is_none() {
-            let file_name = self.source_path.to_str().unwrap().to_string();
-            globals
-                .add(FILE_PATH_VAR.into(), file_name.into())
-                .expect("Failed to set FILE_PATH");
-        }
-
-        if globals.get(&ROOT_PATH_VAR.into()).is_none() {
-            let root_path = self.source_root.to_str().unwrap().to_string();
-            globals
-                .add(ROOT_PATH_VAR.into(), root_path.into())
-                .expect("Failed to set ROOT_PATH");
-        }
+        // FILE_PATH is mandatory
+        globals
+            .get(&FILE_PATH_VAR.into())
+            .expect("FILE_PATH not set");
 
         let mut config = ExecutionConfig::new(&self.sgl.functions, &globals)
             .lazy(true)

tree-sitter-stack-graphs/src/loader.rs

@@ -29,6 +29,7 @@ use tree_sitter_loader::Loader as TsLoader;
 use crate::CancellationFlag;
 use crate::FileAnalyzer;
 use crate::StackGraphLanguage;
+use crate::FILE_PATH_VAR;
 
 pub static DEFAULT_TSG_PATHS: Lazy<Vec<LoadPath>> =
     Lazy::new(|| vec![LoadPath::Grammar("queries/stack-graphs".into())]);
@@ -75,18 +76,23 @@ impl LanguageConfiguration {
         let mut builtins = StackGraph::new();
         if let Some((builtins_path, builtins_source)) = builtins_source {
             let mut builtins_globals = Variables::new();
+
+            let builtins_path_var = Path::new("<builtins>");
+            builtins_globals
+                .add(
+                    FILE_PATH_VAR.into(),
+                    builtins_path_var.to_str().unwrap().into(),
+                )
+                .expect("failed to add file path variable");
+
             if let Some(builtins_config) = builtins_config {
                 Loader::load_globals_from_config_str(builtins_config, &mut builtins_globals)?;
             }
             let file = builtins.add_file("<builtins>").unwrap();
-            let builtins_path_var = Path::new("<builtins>");
-            let builtins_root = Path::new("");
             sgl.build_stack_graph_into(
                 &mut builtins,
                 file,
                 builtins_source,
-                builtins_path_var,
-                builtins_root,
                 &builtins_globals,
                 cancellation_flag,
             )
@@ -332,25 +338,21 @@ impl Loader {
         let file_name = path.to_string_lossy();
         let file: stack_graphs::arena::Handle<stack_graphs::graph::File> =
             graph.add_file(&file_name).unwrap();
-        let builtins_root = Path::new("");
         let mut globals = Variables::new();
+
+        globals
+            .add(FILE_PATH_VAR.into(), path.to_str().unwrap().into())
+            .expect("failed to add file path variable");
+
         Self::load_globals_from_config_str(&config, &mut globals)?;
-        sgl.build_stack_graph_into(
-            graph,
-            file,
-            &source,
-            path,
-            builtins_root,
-            &globals,
-            cancellation_flag,
-        )
-        .map_err(|err| LoadError::Builtins {
-            inner: err,
-            source_path: path.to_path_buf(),
-            source,
-            tsg_path: sgl.tsg_path.to_path_buf(),
-            tsg: sgl.tsg_source.clone(),
-        })?;
+        sgl.build_stack_graph_into(graph, file, &source, &globals, cancellation_flag)
+            .map_err(|err| LoadError::Builtins {
+                inner: err,
+                source_path: path.to_path_buf(),
+                source,
+                tsg_path: sgl.tsg_path.to_path_buf(),
+                tsg: sgl.tsg_source.clone(),
+            })?;
         return Ok(());
     }
 

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

@@ -157,7 +157,6 @@ pub struct Test {
 pub struct TestFragment {
     pub file: Handle<File>,
     pub path: PathBuf,
-    pub root_path: PathBuf,
     pub source: String,
     pub assertions: Vec<Assertion>,
     pub globals: HashMap<String, String>,
@@ -181,7 +180,6 @@ impl Test {
         let mut prev_source = String::new();
         let mut line_files = Vec::new();
         let mut line_count = 0;
-        let default_root_path = PathBuf::from("");
         for (current_line_number, current_line) in
             PositionedSubstring::lines_iter(source).enumerate()
         {
@@ -204,7 +202,6 @@ impl Test {
                     fragments.push(TestFragment {
                         file,
                         path: current_path,
-                        root_path: default_root_path.clone(),
                         source: current_source,
                         assertions: Vec::new(),
                         globals: current_globals,
@@ -257,7 +254,6 @@ impl Test {
             fragments.push(TestFragment {
                 file,
                 path: current_path,
-                root_path: default_root_path.clone(),
                 source: current_source,
                 assertions: Vec::new(),
                 globals: current_globals,

tree-sitter-stack-graphs/tests/it/builder.rs

@@ -36,15 +36,7 @@ fn can_support_preexisting_nodes() {
     let globals = Variables::new();
     let language = StackGraphLanguage::from_str(tree_sitter_python::language(), tsg).unwrap();
     language
-        .build_stack_graph_into(
-            &mut graph,
-            file,
-            python,
-            source_path,
-            source_root,
-            &globals,
-            &NoCancellation,
-        )
+        .build_stack_graph_into(&mut graph, file, python, &globals, &NoCancellation)
         .expect("Failed to build graph");
 }
 
@@ -69,8 +61,7 @@ fn can_support_injected_nodes() {
     let _preexisting_node = graph.add_scope_node(node_id, true).unwrap();
 
     let language = StackGraphLanguage::from_str(tree_sitter_python::language(), tsg).unwrap();
-    let mut builder =
-        language.builder_into_stack_graph(&mut graph, file, python, source_path, source_root);
+    let mut builder = language.builder_into_stack_graph(&mut graph, file, python);
 
     let mut globals = Variables::new();
     globals

tree-sitter-stack-graphs/tests/it/main.rs

@@ -15,6 +15,8 @@ use tree_sitter_stack_graphs::BuildError;
 use tree_sitter_stack_graphs::NoCancellation;
 use tree_sitter_stack_graphs::StackGraphLanguage;
 
+static FILE_PATH_VAR: &'static str = "FILE_PATH";
+
 mod builder;
 mod edges;
 mod loader;
@@ -26,21 +28,18 @@ pub(self) fn build_stack_graph(
     tsg_source: &str,
 ) -> Result<(StackGraph, Handle<File>), BuildError> {
     let file_name = "test.py";
-    let source_path = Path::new(file_name);
-    let source_root = Path::new("");
     let language =
         StackGraphLanguage::from_str(tree_sitter_python::language(), tsg_source).unwrap();
     let mut graph = StackGraph::new();
     let file = graph.get_or_create_file(file_name);
-    let globals = Variables::new();
-    language.build_stack_graph_into(
-        &mut graph,
-        file,
-        python_source,
-        source_path,
-        source_root,
-        &globals,
-        &NoCancellation,
-    )?;
+    let mut globals = Variables::new();
+    let source_path = Path::new(file_name);
+
+    // The FILE_PATH_VAR is not accessible here
+    globals
+        .add(FILE_PATH_VAR.into(), source_path.to_str().unwrap().into())
+        .expect("failed to add file path variable");
+
+    language.build_stack_graph_into(&mut graph, file, python_source, &globals, &NoCancellation)?;
     Ok((graph, file))
 }

tree-sitter-stack-graphs/tests/it/test.rs

@@ -68,22 +68,12 @@ fn build_stack_graph_into(
     graph: &mut StackGraph,
     file: Handle<File>,
     python_source: &str,
-    source_path: &Path,
-    source_root: &Path,
     tsg_source: &str,
     globals: &Variables,
 ) -> Result<(), BuildError> {
     let language =
         StackGraphLanguage::from_str(tree_sitter_python::language(), tsg_source).unwrap();
-    language.build_stack_graph_into(
-        graph,
-        file,
-        python_source,
-        source_path,
-        source_root,
-        globals,
-        &NoCancellation,
-    )?;
+    language.build_stack_graph_into(graph, file, python_source, globals, &NoCancellation)?;
     Ok(())
 }
 
@@ -112,8 +102,6 @@ fn check_test(
             &mut test.graph,
             fragments.file,
             &fragments.source,
-            &fragments.path,
-            &fragments.root_path,
             tsg_source,
             &globals,
         )