Merge pull request #192 from github/java-the-hutt

Update Java rules to support imports

Author: rnkaufman

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

@@ -64,25 +64,54 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
   node @decl.lexical_scope
 }
 
-(import_declaration
-  (scoped_identifier
-    name: (identifier) @scope_name)
-  ) @import {
+(program
+  (package_declaration
+    (identifier)@pkg_name)? @package) @prog {
+  if none @package {
+    edge ROOT_NODE -> @prog.defs
+  } else {
+    node pkg_def
+    attr (pkg_def) node_definition = @pkg_name
+    edge pkg_def -> @prog.defs
+    edge ROOT_NODE -> pkg_def
+  }
+}
+
+(import_declaration (_) @ref) @import {
+  edge @ref.lexical_scope -> @import.lexical_scope
+}
+
+;; X
+(identifier) @name {
+  node @name.lexical_scope
+  node @name.type
+
+  node @name.ref
+  attr (@name.ref) node_reference = @name
+  edge @name.ref -> @name.lexical_scope
+}
+
+;; _.X
+(scoped_identifier scope: (_) @scope name: (_) @name) @scoped_name {
+  node @scoped_name.lexical_scope
+
+  edge @scope.lexical_scope -> @scoped_name.lexical_scope
 
-  node @scope_name.value
-  attr (@scope_name.value) node_definition = @scope_name
+  edge @name.lexical_scope -> @scope.ref
 
-  edge @import.defs -> @scope_name.value
+  node @scoped_name.ref
+  edge @scoped_name.ref -> @name.ref
 }
 
-(import_declaration
-  (scoped_identifier
-    scope: (scoped_identifier
-    name: (identifier) @name))) @import {
-  node @name.value
-  attr (@name.value) node_definition = @name
+[
+  (import_declaration                                            (identifier) @scope @name)
+  (import_declaration (scoped_identifier scope: (_) @scope name: (identifier) @name))
+] @import {
+  node def
+  attr (def) node_definition = @name
+  edge def -> @name.ref
 
-  edge @import.defs -> @name.value
+  edge @import.defs -> def
 }
 
 ;;;;;;;;;;;;;;;;;;;;
@@ -110,6 +139,7 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
   attr (@class_body.lexical_scope -> @class_body.defs) precedence = 1
   edge @class.defs -> def
   edge def -> @class_body.defs
+  edge def -> @class_body.static_defs
 
   node this__expr_def
   node @class.type
@@ -121,6 +151,11 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
 
   attr (@class.type) pop_symbol = ":"
 
+  node def__typeof
+  attr (def__typeof) pop_symbol = ":"
+  edge def -> def__typeof
+  edge def__typeof -> @class_body.static_defs
+
   edge @class.type -> ref
   attr (@class.type -> ref) precedence = 1
 }
@@ -183,15 +218,18 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
 (class_body) @class_body {
   node @class_body.lexical_scope
   node @class_body.defs
+  node @class_body.static_defs
 }
 
 (class_body (_)@declaration)@class_body {
   edge @class_body.defs -> @declaration.defs
+  edge @class_body.static_defs -> @declaration.static_defs
   edge @declaration.lexical_scope -> @class_body.lexical_scope
 }
 
 (class_body (block) @block) {
   node @block.defs
+  node @block.static_defs
   node @block.lexical_scope
   edge @block.lexical_scope -> @block.before_scope
 }
@@ -217,6 +255,7 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
   ; FIXME: can we get away with defining one and only one thing for each of these, and therefore having a `.def` node instead of `.defs`?
   node @decl.defs
   node @decl.lexical_scope
+  node @decl.static_defs
 }
 
 (annotation_type_declaration
@@ -379,14 +418,20 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
 }
 
 (method_declaration
+  (modifiers "static"?@is_static)?
   type: (_) @type
   name: (identifier) @name
   body: (block) @block) @method
 {
   edge @type.lexical_scope -> @method.lexical_scope
 
   node member
-  edge @method.defs -> member
+
+  if none @is_static {
+    edge @method.defs -> member
+  } else {
+    edge @method.static_defs -> member
+  }
 
   attr (member) pop_symbol = "."
 
@@ -825,9 +870,6 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
 }
 
 (resource . (identifier) @name .) @this {
-  node @name.lexical_scope
-  node @name.type
-
   node ref
   node ref__typeof
 
@@ -1043,24 +1085,45 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
 ; Expressions have a lexical scope (propagated to child expressions) and a type. The lexical scope is used for lexical name lookup, while types enable type-based name lookup (for field accesses, method lookup, and so forth).
 
 [
-  (array_access)
   (array_initializer)
-  (expression)
-  (field_access)
+  (assignment_expression)
+  (binary_expression)
+  (instanceof_expression)
+  (lambda_expression)
+  (ternary_expression)
+  (update_expression)
+  (decimal_integer_literal)
+  (hex_integer_literal)
+  (octal_integer_literal)
+  (binary_integer_literal)
+  (decimal_floating_point_literal)
+  (hex_floating_point_literal)
+  (true)
+  (false)
+  (character_literal)
+  (string_literal)
+  (null_literal)
+  (class_literal)
+  (this)
+  ; (identifier)
   (parenthesized_expression)
-  (primary_expression)
+  (object_creation_expression)
+  (field_access)
+  (array_access)
+  (method_invocation)
+  (method_reference)
+  (array_creation_expression)
+  (unary_expression)
+  (cast_expression)
+  (switch_expression)
   (super)
-  (this)
 ] @expr
 {
   node @expr.type
   node @expr.lexical_scope
 }
 
 (assignment_expression left: (identifier) @name) @this {
-  ; FIXME: can we combine this with primary_expression/identifier?
-  node @name.lexical_scope
-  node @name.type
   node member
   node implicit_this
   node implicit_this__typeof
@@ -1251,6 +1314,10 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
   edge @type.lexical_scope -> @this.lexical_scope
 }
 
+(scoped_type_identifier . (_) @name) @this {
+  edge @name.lexical_scope -> @this.lexical_scope
+}
+
 (wildcard) @this
 {
   node @this.lexical_scope
@@ -1261,6 +1328,16 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
   edge @this.type -> @this.lexical_scope
 }
 
+(scoped_type_identifier
+  (type_identifier) @imported_class_name (type_identifier) @method_name) {
+
+  node member
+  attr (member) push_symbol = "."
+
+  edge @method_name.type -> member
+  edge member -> @imported_class_name.type
+}
+
 ;; ==========
 ;;  Comments
 ;; ==========
@@ -1271,6 +1348,8 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
   node @line_comment.lexical_defs
   node @line_comment.lexical_scope
   node @line_comment.defs
+  node @line_comment.ref
+  node @line_comment.static_defs
 
   edge @line_comment.after_scope -> @line_comment.before_scope
 }
@@ -1279,6 +1358,8 @@ attribute node_symbol = node            => symbol = (source-text node), source_n
   node @block_comment.before_scope
   node @block_comment.after_scope
   node @block_comment.defs
+  node @block_comment.ref
+  node @block_comment.static_defs
   node @block_comment.lexical_scope
 
   edge @block_comment.after_scope -> @block_comment.before_scope

languages/tree-sitter-stack-graphs-java/test/imports_and_exports/import_method.java

@@ -0,0 +1,18 @@
+/*--- path: Importer.java ---*/
+import foo.Foo;
+
+public class Importer {
+  public static void main(String[] args) {
+    Foo.bar();
+     // ^ defined: 16
+
+  }
+}
+
+/* --- path: foo/Foo.java ---*/
+package foo;
+
+public class Foo {
+  public static void bar() {
+  }
+}

languages/tree-sitter-stack-graphs-java/test/imports_and_exports/imports.java

@@ -1,20 +1,15 @@
-/*--- path: a.java ---*/
-import foo.bar.Baz;
+/*--- path: Importer.java ---*/
+import foo.Foo;
+        // ^ defined: 14
 
 public class Importer {
-  public static void main(String[] args) {
-    Baz.some_method();
-  // ^ defined: 2
+  public Foo test() {
+      // ^ defined: 2, 14
   }
 }
 
+/* --- path: foo/Foo.java ---*/
+package foo;
 
-/* --- path: b.java ---*/
-
-import foo.bar.Baz;
-
-public class AnotherImporter {
-  public static void main(String[] args) {
-    Baz.some_method();
-  }
+public class Foo {
 }

languages/tree-sitter-stack-graphs-java/test/imports_and_exports/no_package.java

@@ -0,0 +1,10 @@
+/*--- path: Importer.java ---*/
+public class Importer {
+  public Foo test() {
+      // ^ defined: 9
+  }
+}
+
+/* --- path: Foo.java ---*/
+public class Foo {
+}

languages/tree-sitter-stack-graphs-java/test/imports_and_exports/no_package_method.java

@@ -0,0 +1,14 @@
+/*--- path: Importer.java ---*/
+public class Importer {
+  public static void main(String[] args) {
+    Foo.bar();
+     // ^ defined: 12
+
+  }
+}
+
+/* --- path: Foo.java ---*/
+public class Foo {
+  public static void bar() {
+  }
+}

languages/tree-sitter-stack-graphs-java/test/imports_and_exports/no_package_not_leaking_method.java

@@ -0,0 +1,13 @@
+/*--- path: Importer.java ---*/
+public class Importer {
+  public static void main(String[] args) {
+    bar();
+ // ^ defined:
+  }
+}
+
+/* --- path: Foo.java ---*/
+public class Foo {
+  public static void bar() {
+  }
+}