Implement refinement

Refinements are part of modules that provide additional instance methods on classes that can be brought into scope by `using` the module. Because refinements are not globally available, method resolution must carry scope of the call to allow finding refinements at the call site. A detailed example of refinement with the corresponding stack graph is included in `doc/refinement.png`.
hendrikvanantwerpen · May 11, 2023 · May 11, 2023 · May 11, 2023 · May 12, 2023 · May 12, 2023
commit 2ef2114b182eac5a8bb1a0dadd10546d2024acbe
@@ -30,8 +30,10 @@ cli = ["anyhow", "clap", "tree-sitter-stack-graphs/cli"]
 [dependencies]
 anyhow = { version = "1.0", optional = true }
 clap = { version = "4", optional = true, features = ["derive"] }
+tree-sitter-graph = { version = "0.10.0" }
 tree-sitter-stack-graphs = { version = "0.6.0", path = "../../tree-sitter-stack-graphs" }
 tree-sitter-ruby = "0.20.0"
+uuid = { version = "1.3", features = ["v4", "fast-rng"] }
 
 [dev-dependencies]
 anyhow = "1.0"

@@ -32,7 +32,7 @@ pub fn language_configuration(cancellation_flag: &dyn CancellationFlag) -> Langu
 pub fn try_language_configuration(
     cancellation_flag: &dyn CancellationFlag,
 ) -> Result<LanguageConfiguration, LoadError> {
-    LanguageConfiguration::from_sources(
+    let mut lc = LanguageConfiguration::from_sources(
         tree_sitter_ruby::language(),
         Some(String::from("source.rb")),
         None,
@@ -46,5 +46,21 @@ pub fn try_language_configuration(
         Some(STACK_GRAPHS_BUILTINS_CONFIG),
         FileAnalyzers::new(),
         cancellation_flag,
-    )
+    )?;
+    lc.sgl.functions_mut().add("uuid".into(), UUID);
+    Ok(lc)
+}
+
+struct UUID;
+
+impl tree_sitter_graph::functions::Function for UUID {
+    fn call(
+        &self,
+        _graph: &mut tree_sitter_graph::graph::Graph,
+        _source: &str,
+        parameters: &mut dyn tree_sitter_graph::functions::Parameters,
+    ) -> Result<tree_sitter_graph::graph::Value, tree_sitter_graph::ExecutionError> {
+        parameters.finish()?;
+        Ok(uuid::Uuid::new_v4().to_string().into())
+    }
 }
@@ -120,16 +120,52 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
     edge @name.ref -> @class.lexical_scope
 }
 
-(class body:(_)@body) {
+(class)@class {
+    node @class.instance
+}
+
+(class name:(_)@name)@class {
     node dot
     attr (dot) pop_symbol = "."
 
     node def
     attr (def) pop_symbol = "new"
 
-    edge @body.static_defs -> dot
+    edge @name.def_value -> dot
     edge dot -> def
-    edge def -> @body.instance_defs
+    edge def -> @class.instance
+}
+
+(class body:(_)@body)@class {
+    edge @class.instance -> @body.instance_defs
+}
+
+(class name:(_)@name)@class {
+    let nonce = (uuid)
+
+    node refine_in
+    attr (refine_in) pop_scoped_symbol = "<refine-in>"
+    ;
+    node push_nonce
+    attr (push_nonce) push_symbol = nonce
+    ;
+    node using
+    attr (using) push_symbol = "<using>"
+    ;
+    edge @class.instance -> refine_in
+    edge refine_in -> push_nonce
+    edge push_nonce -> using
+    edge using -> JUMP_TO_SCOPE_NODE
+
+    node refine
+    attr (refine) pop_scoped_symbol = "<refine>"
+    ;
+    node pop_nonce
+    attr (pop_nonce) pop_symbol = nonce
+    ;
+    edge @name.def_value -> refine
+    edge refine -> pop_nonce
+    edge pop_nonce -> JUMP_TO_SCOPE_NODE
 }
 
 [
@@ -235,6 +271,22 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
     edge @recv.lexical_scope -> @call.lexical_scope
 }
 
+(call receiver:(_)@recv method:(_)@mthd_name)@call {
+    node dot
+    attr (dot) push_symbol = "."
+
+    node refine_scope
+    attr (refine_scope) is_endpoint
+    edge refine_scope -> @call.lexical_scope
+
+    node refine_in
+    attr (refine_in) push_scoped_symbol = "<refine-in>", scope = refine_scope
+
+    edge @mthd_name.ref -> dot
+    edge dot -> refine_in
+    edge refine_in -> @recv.value
+}
+
 (method name:(_)@name)@method {
     node dot
     attr (dot) pop_symbol = "."
@@ -246,6 +298,23 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
     edge dot -> def
 }
 
+;; refine
+(call method:(_)@refine arguments:(argument_list (_)@name) block:(do_block body:(_)@body))@call {
+if (eq "refine" (source-text @refine)) {
+    node refine_scope
+    attr (refine_scope) is_endpoint
+
+    node refine
+    attr (refine) push_scoped_symbol = "<refine>", scope = refine_scope
+
+    edge @call.static_defs -> refine
+    edge refine -> @name.ref_value
+    edge @name.ref -> @call.lexical_scope
+
+    edge refine_scope -> @body.instance_defs
+}
+}
+
 (singleton_method name:(_)@name)@method {
     node dot
     attr (dot) pop_symbol = "."
@@ -257,6 +326,18 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
     edge dot -> def
 }
 
+;; using
+(call method:(_)@using arguments:(argument_list (_)@name))@call {
+if (eq "using" (source-text @using)) {
+    node using
+    attr (using) pop_symbol = "<using>"
+
+    edge @call.local_defs -> using
+    edge using -> @name.ref_value
+    edge @name.ref -> @call.lexical_scope
+}
+}
+
 ;; Identifiers
 ;; ^^^^^^^^^^^
 

@@ -0,0 +1,23 @@
+class C
+end
+
+  C.new.foo
+# ^ defined: 1
+#       ^ defined:
+
+module M
+    refine C do
+        def foo
+        end
+    end
+end
+
+  C.new.foo
+# ^ defined: 1
+#       ^ defined:
+
+using M
+
+  C.new.foo
+# ^ defined: 1
+#       ^ defined: 10