Merge pull request #135 from tree-sitter/inherited-scoped-variables

Inherited scoped variables

CHANGELOG.md

···
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.10.3 -- 2023-06-01
+
+### DSL
+
+#### Added
+
+- Scoped variables can be inherited by child nodes by specifying `inherit .var_name` as part of the source. Using `@node.var_name` will either use the value set on the node itself, or otherwise the one set on the closest enclosing node.
+
 ## v0.10.2 -- 2023-05-25
 
 ### Library

Cargo.toml

···
 [package]
 name = "tree-sitter-graph"
-version = "0.10.2"
+version = "0.10.3"
 description = "Construct graphs from parsed source code"
 homepage = "https://github.com/tree-sitter/tree-sitter-graph/"
 repository = "https://github.com/tree-sitter/tree-sitter-graph/"

src/ast.rs

···
 
 use regex::Regex;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::fmt;
 use tree_sitter::CaptureQuantifier;
 use tree_sitter::Language;
···
     pub language: Language,
     /// The expected global variables used in this file
     pub globals: Vec<Global>,
+    /// The scoped variables that are inherited by child nodes
+    pub inherited_variables: HashSet<Identifier>,
     /// The combined query of all stanzas in the file
     pub query: Option<Query>,
     /// The list of stanzas in the file
···
         File {
             language,
             globals: Vec::new(),
+            inherited_variables: HashSet::new(),
             query: None,
             stanzas: Vec::new(),
             shorthands: AttributeShorthands::new(),

src/execution/lazy.rs

···
 use log::{debug, trace};
 
 use std::collections::HashMap;
+use std::collections::HashSet;
 
 use tree_sitter::QueryCursor;
 use tree_sitter::QueryMatch;
···
                 &mut lazy_graph,
                 &mut function_parameters,
                 &mut prev_element_debug_info,
+                &self.inherited_variables,
                 &self.shorthands,
                 cancellation_flag,
             )
···
             functions: config.functions,
             store: &store,
             scoped_store: &scoped_store,
+            inherited_variables: &self.inherited_variables,
             function_parameters: &mut function_parameters,
             prev_element_debug_info: &mut prev_element_debug_info,
             cancellation_flag,
···
     function_parameters: &'a mut Vec<graph::Value>, // re-usable buffer to reduce memory allocations
     prev_element_debug_info: &'a mut HashMap<GraphElementKey, DebugInfo>,
     error_context: StatementContext,
+    inherited_variables: &'a HashSet<Identifier>,
     shorthands: &'a ast::AttributeShorthands,
     cancellation_flag: &'a dyn CancellationFlag,
 }
···
     pub functions: &'a Functions,
     pub store: &'a LazyStore,
     pub scoped_store: &'a LazyScopedVariables,
+    pub inherited_variables: &'a HashSet<Identifier>,
     pub function_parameters: &'a mut Vec<graph::Value>, // re-usable buffer to reduce memory allocations
     pub prev_element_debug_info: &'a mut HashMap<GraphElementKey, DebugInfo>,
     pub cancellation_flag: &'a dyn CancellationFlag,
···
         lazy_graph: &mut Vec<LazyStatement>,
         function_parameters: &mut Vec<graph::Value>,
         prev_element_debug_info: &mut HashMap<GraphElementKey, DebugInfo>,
+        inherited_variables: &HashSet<Identifier>,
         shorthands: &ast::AttributeShorthands,
         cancellation_flag: &dyn CancellationFlag,
     ) -> Result<(), ExecutionError> {
···
                 function_parameters,
                 prev_element_debug_info,
                 error_context,
+                inherited_variables,
                 shorthands,
                 cancellation_flag,
             };
···
                 function_parameters: exec.function_parameters,
                 prev_element_debug_info: exec.prev_element_debug_info,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
                     function_parameters: exec.function_parameters,
                     prev_element_debug_info: exec.prev_element_debug_info,
                     error_context: exec.error_context.clone(),
+                    inherited_variables: exec.inherited_variables,
                     shorthands: exec.shorthands,
                     cancellation_flag: exec.cancellation_flag,
                 };
···
                 function_parameters: exec.function_parameters,
                 prev_element_debug_info: exec.prev_element_debug_info,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
             functions: exec.config.functions,
             store: exec.store,
             scoped_store: exec.scoped_store,
+            inherited_variables: exec.inherited_variables,
             function_parameters: exec.function_parameters,
             prev_element_debug_info: exec.prev_element_debug_info,
             cancellation_flag: exec.cancellation_flag,
···
                 function_parameters: exec.function_parameters,
                 prev_element_debug_info: exec.prev_element_debug_info,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
                 function_parameters: exec.function_parameters,
                 prev_element_debug_info: exec.prev_element_debug_info,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
             function_parameters: exec.function_parameters,
             prev_element_debug_info: exec.prev_element_debug_info,
             error_context: exec.error_context.clone(),
+            inherited_variables: exec.inherited_variables,
             shorthands: exec.shorthands,
             cancellation_flag: exec.cancellation_flag,
         };

src/execution/lazy/store.rs

···
 use crate::execution::error::ResultWithExecutionError;
 use crate::execution::error::StatementContext;
 use crate::graph;
+use crate::graph::SyntaxNodeID;
 use crate::graph::SyntaxNodeRef;
 use crate::Identifier;
 
···
         };
         let values = cell.replace(ScopedValues::Forcing);
         let map = self.force(name, values, exec)?;
-        let result = map
-            .get(&scope)
-            .ok_or(ExecutionError::UndefinedScopedVariable(format!(
-                "{}.{}",
-                scope, name,
-            )))?
-            .clone();
+
+        let mut result = None;
+
+        if let Some(value) = map.get(&scope.index) {
+            result = Some(value.clone());
+        } else if exec.inherited_variables.contains(name) {
+            let mut parent = exec
+                .graph
+                .syntax_nodes
+                .get(&scope.index)
+                .and_then(|n| n.parent());
+            while let Some(scope) = parent {
+                if let Some(value) = map.get(&(scope.id() as u32)) {
+                    result = Some(value.clone());
+                    break;
+                }
+                parent = scope.parent();
+            }
+        }
+
         cell.replace(ScopedValues::Forced(map));
-        Ok(result)
+        result.ok_or_else(|| ExecutionError::UndefinedScopedVariable(format!("{}.{}", scope, name)))
     }
 
     pub(super) fn evaluate_all(&self, exec: &mut EvaluationContext) -> Result<(), ExecutionError> {
···
         name: &Identifier,
         values: ScopedValues,
         exec: &mut EvaluationContext,
-    ) -> Result<HashMap<SyntaxNodeRef, LazyValue>, ExecutionError> {
+    ) -> Result<HashMap<SyntaxNodeID, LazyValue>, ExecutionError> {
         match values {
             ScopedValues::Unforced(pairs) => {
                 let mut map = HashMap::new();
···
                         .with_context(|| format!("Evaluating scope of variable _.{}", name,).into())
                         .with_context(|| debug_info.0.clone().into())?;
                     let prev_debug_info = debug_infos.insert(node, debug_info.clone());
-                    match map.insert(node, value.clone()) {
+                    match map.insert(node.index, value.clone()) {
                         Some(_) => {
                             return Err(ExecutionError::DuplicateVariable(format!(
                                 "{}.{}",
···
 enum ScopedValues {
     Unforced(Vec<(LazyValue, LazyValue, DebugInfo)>),
     Forcing,
-    Forced(HashMap<SyntaxNodeRef, LazyValue>),
+    Forced(HashMap<SyntaxNodeID, LazyValue>),
 }
 
 impl ScopedValues {

src/execution/strict.rs

···
 
 use std::collections::BTreeSet;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use tree_sitter::QueryCursor;
 use tree_sitter::QueryMatch;
 use tree_sitter::Tree;
···
 use crate::execution::CancellationFlag;
 use crate::execution::ExecutionConfig;
 use crate::graph::Graph;
+use crate::graph::SyntaxNodeID;
 use crate::graph::SyntaxNodeRef;
 use crate::graph::Value;
 use crate::variables::Globals;
···
                 &mut scoped,
                 &current_regex_captures,
                 &mut function_parameters,
+                &self.inherited_variables,
                 &self.shorthands,
                 cancellation_flag,
             )
···
     function_parameters: &'a mut Vec<Value>,
     mat: &'a QueryMatch<'a, 'tree>,
     error_context: StatementContext,
+    inherited_variables: &'a HashSet<Identifier>,
     shorthands: &'a AttributeShorthands,
     cancellation_flag: &'a dyn CancellationFlag,
 }
 
 struct ScopedVariables<'a> {
-    scopes: HashMap<SyntaxNodeRef, VariableMap<'a, Value>>,
+    scopes: HashMap<SyntaxNodeID, VariableMap<'a, Value>>,
 }
 
 impl<'a> ScopedVariables<'a> {
···
         }
     }
 
-    fn get(&mut self, scope: SyntaxNodeRef) -> &mut VariableMap<'a, Value> {
-        self.scopes.entry(scope).or_insert(VariableMap::new())
+    fn get_mut(&mut self, scope: SyntaxNodeRef) -> &mut VariableMap<'a, Value> {
+        self.scopes.entry(scope.index).or_insert(VariableMap::new())
+    }
+
+    fn try_get(&self, index: SyntaxNodeID) -> Option<&VariableMap<'a, Value>> {
+        self.scopes.get(&index)
     }
 }
 
···
         scoped: &mut ScopedVariables<'s>,
         current_regex_captures: &Vec<String>,
         function_parameters: &mut Vec<Value>,
+        inherited_variables: &HashSet<Identifier>,
         shorthands: &AttributeShorthands,
         cancellation_flag: &dyn CancellationFlag,
     ) -> Result<(), ExecutionError> {
···
                 function_parameters,
                 mat: &mat,
                 error_context,
+                inherited_variables,
                 shorthands,
                 cancellation_flag,
             };
···
                 function_parameters: exec.function_parameters,
                 mat: exec.mat,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
                     function_parameters: exec.function_parameters,
                     mat: exec.mat,
                     error_context: exec.error_context.clone(),
+                    inherited_variables: exec.inherited_variables,
                     shorthands: exec.shorthands,
                     cancellation_flag: exec.cancellation_flag,
                 };
···
                 function_parameters: exec.function_parameters,
                 mat: exec.mat,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
                 function_parameters: exec.function_parameters,
                 mat: exec.mat,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
                 function_parameters: exec.function_parameters,
                 mat: exec.mat,
                 error_context: exec.error_context.clone(),
+                inherited_variables: exec.inherited_variables,
                 shorthands: exec.shorthands,
                 cancellation_flag: exec.cancellation_flag,
             };
···
                 )))
             }
         };
-        let variables = exec.scoped.get(scope);
-        if let Some(value) = variables.get(&self.name) {
-            Ok(value)
-        } else {
-            Err(ExecutionError::UndefinedVariable(format!(
-                "{} on node {}",
-                self, scope
-            )))
+
+        // search this node
+        if let Some(value) = exec
+            .scoped
+            .try_get(scope.index)
+            .and_then(|v| v.get(&self.name))
+        {
+            return Ok(value);
         }
+
+        // search parent nodes
+        if exec.inherited_variables.contains(&self.name) {
+            let mut parent = exec
+                .graph
+                .syntax_nodes
+                .get(&scope.index)
+                .and_then(|n| n.parent());
+            while let Some(scope) = parent {
+                if let Some(value) = exec
+                    .scoped
+                    .try_get(scope.id() as u32)
+                    .and_then(|v| v.get(&self.name))
+                {
+                    return Ok(value);
+                }
+                parent = scope.parent();
+            }
+        }
+
+        Err(ExecutionError::UndefinedVariable(format!(
+            "{} on node {}",
+            self, scope
+        )))
     }
 
     fn add(
···
                 )))
             }
         };
-        let variables = exec.scoped.get(scope);
+        let variables = exec.scoped.get_mut(scope);
         variables
             .add(self.name.clone(), value, mutable)
             .map_err(|_| ExecutionError::DuplicateVariable(format!("{}", self)))
···
                 )))
             }
         };
-        let variables = exec.scoped.get(scope);
+        let variables = exec.scoped.get_mut(scope);
         variables
             .set(self.name.clone(), value)
             .map_err(|_| ExecutionError::DuplicateVariable(format!("{}", self)))
···
             function_parameters: exec.function_parameters,
             mat: exec.mat,
             error_context: exec.error_context.clone(),
+            inherited_variables: exec.inherited_variables,
             shorthands: exec.shorthands,
             cancellation_flag: exec.cancellation_flag,
         };

src/graph.rs

···
 /// that they don't outlive the tree-sitter syntax tree that they are generated from.
 #[derive(Default)]
 pub struct Graph<'tree> {
-    syntax_nodes: HashMap<SyntaxNodeID, Node<'tree>>,
+    pub(crate) syntax_nodes: HashMap<SyntaxNodeID, Node<'tree>>,
     graph_nodes: Vec<GraphNode>,
 }
 
-type SyntaxNodeID = u32;
+pub(crate) type SyntaxNodeID = u32;
 type GraphNodeID = u32;
 
 impl<'tree> Graph<'tree> {
···
 /// A reference to a syntax node in a graph
 #[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct SyntaxNodeRef {
-    index: SyntaxNodeID,
+    pub(crate) index: SyntaxNodeID,
     kind: &'static str,
     position: tree_sitter::Point,
 }

src/parser.rs

···
     fn parse_into_file(&mut self, file: &mut ast::File) -> Result<(), ParseError> {
         self.consume_whitespace();
         while self.try_peek().is_some() {
-            if let Ok(_) = self.consume_token("global") {
+            if let Ok(_) = self.consume_token("attribute") {
+                self.consume_whitespace();
+                let shorthand = self.parse_shorthand()?;
+                file.shorthands.add(shorthand);
+            } else if let Ok(_) = self.consume_token("global") {
                 self.consume_whitespace();
                 let global = self.parse_global()?;
                 file.globals.push(global);
-            } else if let Ok(_) = self.consume_token("attribute") {
+            } else if let Ok(_) = self.consume_token("inherit") {
                 self.consume_whitespace();
-                let shorthand = self.parse_shorthand()?;
-                file.shorthands.add(shorthand);
+                self.consume_token(".")?;
+                let name = self.parse_identifier("inherit")?;
+                file.inherited_variables.insert(name);
             } else {
                 let stanza = self.parse_stanza(file.language)?;
                 file.stanzas.push(stanza);

tests/it/execution.rs

···
         "#},
     );
 }
+
+#[test]
+fn can_access_inherited_attribute() {
+    check_execution(
+        indoc! { r#"
+          def get_f():
+            pass
+        "#},
+        indoc! {r#"
+            inherit .test
+            (function_definition)@def {
+              node @def.test
+              attr (@def.test) in_def
+            }
+            (pass_statement)@pass {
+              attr (@pass.test) in_pass
+            }
+        "#},
+        indoc! {r#"
+          node 0
+            in_def: #true
+            in_pass: #true
+        "#},
+    );
+}
+
+#[test]
+fn can_overwrite_inherited_attribute() {
+    check_execution(
+        indoc! { r#"
+          def get_f():
+            pass
+        "#},
+        indoc! {r#"
+            inherit .test
+            (function_definition)@def {
+              node @def.test
+              attr (@def.test) in_def
+            }
+            (pass_statement)@pass {
+              node @pass.test
+            }
+            (pass_statement)@pass {
+              attr (@pass.test) in_pass
+            }
+        "#},
+        indoc! {r#"
+          node 0
+            in_def: #true
+          node 1
+            in_pass: #true
+        "#},
+    );
+}
+
+#[test]
+fn cannot_access_non_inherited_variable() {
+    fail_execution(
+        indoc! { r#"
+          def get_f():
+            pass
+        "#},
+        indoc! {r#"
+            (function_definition)@def {
+              node @def.test
+            }
+            (pass_statement)@pass {
+              attr (@pass.test) in_pass
+            }
+        "#},
+    );
+}

tests/it/lazy_execution.rs

···
         "#},
     );
 }
+
+#[test]
+fn can_access_inherited_attribute() {
+    check_execution(
+        indoc! { r#"
+          def get_f():
+            pass
+        "#},
+        indoc! {r#"
+            inherit .test
+            (function_definition)@def {
+              node @def.test
+              attr (@def.test) in_def
+            }
+            (pass_statement)@pass {
+              attr (@pass.test) in_pass
+            }
+        "#},
+        indoc! {r#"
+          node 0
+            in_def: #true
+            in_pass: #true
+        "#},
+    );
+}
+
+#[test]
+fn can_overwrite_inherited_attribute() {
+    check_execution(
+        indoc! { r#"
+          def get_f():
+            pass
+        "#},
+        indoc! {r#"
+            inherit .test
+            (function_definition)@def {
+              node @def.test
+              attr (@def.test) in_def
+            }
+            (pass_statement)@pass {
+              node @pass.test
+            }
+            (pass_statement)@pass {
+              attr (@pass.test) in_pass
+            }
+        "#},
+        indoc! {r#"
+          node 0
+            in_def: #true
+          node 1
+            in_pass: #true
+        "#},
+    );
+}
+
+#[test]
+fn cannot_access_non_inherited_variable() {
+    fail_execution(
+        indoc! { r#"
+          def get_f():
+            pass
+        "#},
+        indoc! {r#"
+            (function_definition)@def {
+              node @def.test
+            }
+            (pass_statement)@pass {
+              attr (@pass.test) in_pass
+            }
+        "#},
+    );
+}

tests/it/parser.rs

···
     "#;
     File::from_str(tree_sitter_python::language(), source).expect("parse to succeed");
 }
+
+#[test]
+fn can_parse_inherit_directives() {
+    let source = r#"
+        inherit .scope
+    "#;
+    let file = File::from_str(tree_sitter_python::language(), source).expect("parse to succeed");
+    assert!(file.inherited_variables.contains("scope".into()));
+}

vscode/CHANGELOG.md

···
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.1 -- 2023-06-01
+
+### Added
+
+- Add new `inherit` keyword
+
 ## 0.1.0 -- 2022-05-11
 
 ### Added

vscode/package.json

···
 {
     "name": "tree-sitter-graph",
-    "version": "0.1.0",
+    "version": "0.1.1",
     "publisher": "tree-sitter",
     "engines": {
         "vscode": "^1.60.0"

vscode/syntaxes/tree-sitter-graph.tmLanguage.json

···
 		"keywords": {
 			"patterns": [{
 				"name": "keyword.control.tsg",
-				"match": "^\\s*(attr|attribute|edge|for|global|if|let|node|none|print|scan|set|some|var)\\b"
+				"match": "^\\s*(attr|attribute|edge|for|global|if|inherit|let|node|none|print|scan|set|some|var)\\b"
 			}]
 		},
 		"functions": {