Various improvements (tree-sitter#13)

* Add supertypes

* Support multi-line case clauses

* Allow definitions in case clauses, expressions in class/object bodies

* Add annotations, infix patterns, implicit parameters

* Add tree-sitter CLI declaration to package.json

* Add annotations on type parameters

* Add type annotations, type projections; fix compound types

* Fix operator_identifier regexp

* Add tuple types and repeated parameter types

* Give infix_pattern higher precedence than capture_pattern

* Make infix_type nestable

* Allow body-less trait_definition

* Allow omitting parens when function_type's input is a single type

* Put all alternatives function_type's parameters under parameter_types

* Give alternative_pattern lower precedence than typed_pattern

* Remove parenthesized_pattern

* Allow empty body in case_clause

* Regenerate parser

Author: ubolonton

corpus/annotations.txt

@@ -0,0 +1,87 @@
+================================
+Classes
+================================
+
+@deprecated("Use D", "1.0") class C {}
+
+---
+
+(compilation_unit
+  (class_definition
+    (annotation (type_identifier) (arguments (string) (string)))
+    (identifier)
+    (template_body)))
+
+================================
+Declarations and definitions
+================================
+
+class A(x: String) {
+  @transient @volatile var y: Int
+  @transient @volatile val z = x
+
+  @throws(Error)
+  @deprecated(message = "Don't use this", since = "1.0")
+  def foo() {}
+}
+
+---
+
+(compilation_unit
+  (class_definition (identifier)
+    (class_parameters (class_parameter (identifier) (type_identifier)))
+    (template_body
+      (var_declaration
+        (annotation (type_identifier))
+        (annotation (type_identifier))
+        (identifier) (type_identifier))
+      (val_definition
+        (annotation (type_identifier))
+        (annotation (type_identifier))
+        (identifier) (identifier))
+      (function_definition
+        (annotation (type_identifier) (arguments (identifier)))
+        (annotation (type_identifier)
+          (arguments
+            (assignment_expression (identifier) (string))
+            (assignment_expression (identifier) (string))))
+        (identifier) (parameters) (block)))))
+
+================================
+Parameters
+================================
+
+class A(@one x: String) {
+  def foo(@another x: Int) {}
+}
+
+---
+
+(compilation_unit
+  (class_definition (identifier)
+    (class_parameters
+      (class_parameter
+        (annotation (type_identifier)) (identifier) (type_identifier)))
+    (template_body
+      (function_definition
+        (identifier)
+        (parameters (parameter
+                      (annotation (type_identifier))
+                      (identifier) (type_identifier)))
+        (block)))))
+
+================================
+Types
+================================
+
+trait Function0[@specialized(Unit, Int, Double) T] {
+  def apply: T
+}
+
+---
+
+(compilation_unit
+  (trait_definition (identifier)
+    (type_parameters
+      (annotation (type_identifier) (arguments (identifier) (identifier) (identifier))) (identifier))
+    (template_body (function_declaration (identifier) (type_identifier)))))

corpus/definitions.txt

@@ -151,7 +151,7 @@ class A(b: B) extends C(b || ok) {
 Class definitions with parameters
 =======================================
 
-class Point(val x: Int, val y: Int)
+class Point(val x: Int, val y: Int)(implicit coord: Coord)
 
 ---
 
@@ -160,6 +160,8 @@ class Point(val x: Int, val y: Int)
     (identifier)
     (class_parameters
       (class_parameter (identifier) (type_identifier))
+      (class_parameter (identifier) (type_identifier)))
+    (class_parameters
       (class_parameter (identifier) (type_identifier)))))
 
 =======================================
@@ -187,6 +189,10 @@ implicit final sealed class Point {
 Trait definitions
 =======================================
 
+trait A extends B
+
+trait A extends B with C
+
 trait T[U] {
 }
 
@@ -196,6 +202,12 @@ trait T[U] extends V.W[U] {
 ---
 
 (compilation_unit
+  (trait_definition
+    (identifier)
+    (extends_clause (type_identifier)))
+  (trait_definition
+    (identifier)
+    (extends_clause (compound_type (type_identifier) (type_identifier))))
   (trait_definition
     (identifier)
     (type_parameters (identifier))
@@ -347,6 +359,7 @@ class A {
   def g[H](i) {
     j
   }
+  def h(x: T)(implicit ev: Reads[T])
 }
 
 ---
@@ -365,7 +378,31 @@ class A {
         (identifier)
         (type_parameters (identifier))
         (parameters (parameter (identifier)))
-        (block (identifier))))))
+        (block (identifier)))
+      (function_declaration
+        (identifier)
+        (parameters (parameter (identifier) (type_identifier)))
+        (parameters (parameter (identifier) (generic_type (type_identifier) (type_arguments (type_identifier)))))))))
+
+=======================================
+Initialization expressions
+=======================================
+
+class A(val x: Int, val y: Int) {
+  assert(x != 0)
+}
+
+---
+
+(compilation_unit
+  (class_definition
+    (identifier)
+    (class_parameters
+      (class_parameter (identifier) (type_identifier))
+      (class_parameter (identifier) (type_identifier)))
+    (template_body
+      (call_expression (identifier)
+        (arguments (infix_expression (identifier) (operator_identifier) (number)))))))
 
 =======================================
 Optional parameters

corpus/expressions.txt

@@ -161,9 +161,15 @@ Match expressions
 ===============================
 
 def matchTest(x: Int): String = x match {
+  case 0 =>
   case 1 => "one"; "uno"
   case 2 => "two"
-  case _ => "many"
+  case 3 => {
+    "3"
+  }
+  case _ =>
+    val x = "many"
+    "more"
 }
 
 ---
@@ -174,9 +180,11 @@ def matchTest(x: Int): String = x match {
     (parameters (parameter (identifier) (type_identifier)))
     (type_identifier)
     (match_expression (identifier) (case_block
+      (case_clause (number))
       (case_clause (number) (string) (string))
       (case_clause (number) (string))
-      (case_clause (wildcard) (string))))))
+      (case_clause (number) (block (string)))
+      (case_clause (wildcard) (val_definition (identifier) (string)) (string))))))
 
 ===============================
 Field expressions

corpus/patterns.txt

@@ -29,6 +29,7 @@ Typed patterns
 val x = y match {
   case 1 : Int => 2
   case a : B with C => d
+  case _: B | _: C => 3
 }
 
 ---
@@ -41,14 +42,23 @@ val x = y match {
         (typed_pattern (number) (type_identifier)) (number))
       (case_clause
         (typed_pattern (identifier) (compound_type (type_identifier) (type_identifier)))
-        (identifier))))))
+        (identifier))
+      (case_clause
+        (alternative_pattern
+          (typed_pattern (wildcard) (type_identifier))
+          (typed_pattern (wildcard) (type_identifier)))
+        (number))))))
 
 ============================
 Tuple patterns
 ============================
 
 val (a, b) = if (c) (d, e) else (f, g)
 
+val x = y match {
+  case (A, B) => X
+}
+
 ---
 
 (compilation_unit
@@ -57,7 +67,12 @@ val (a, b) = if (c) (d, e) else (f, g)
     (if_expression
       (parenthesized_expression (identifier))
       (tuple_expression (identifier) (identifier))
-      (tuple_expression (identifier) (identifier)))))
+      (tuple_expression (identifier) (identifier))))
+  (val_definition (identifier)
+    (match_expression (identifier)
+      (case_block
+        (case_clause
+          (tuple_pattern (identifier) (identifier)) (identifier))))))
 
 ============================
 Case class patterns
@@ -93,12 +108,34 @@ def showNotification(notification: Notification): String = {
           (case_class_pattern (type_identifier) (identifier) (identifier))
           (string_transform_expression (identifier) (string (interpolation (identifier)) (interpolation (identifier))))))))))
 
+============================
+Infix patterns
+============================
+
+def first(x: Seq[Int]) = x match {
+  case e :+ _ => Some(e)
+  case _ => None
+}
+
+---
+
+(compilation_unit
+  (function_definition (identifier)
+    (parameters (parameter (identifier) (generic_type (type_identifier) (type_arguments (type_identifier)))))
+    (match_expression (identifier)
+      (case_block
+        (case_clause (infix_pattern (identifier) (operator_identifier) (wildcard))
+          (call_expression (identifier) (arguments (identifier))))
+        (case_clause (wildcard)
+          (identifier))))))
+
 ============================
 Capture patterns
 ============================
 
 val x = y match {
-  case a @ B(1) => c
+  case a @ B(1) => a
+  case b @ C(d @ (e @ X, _: Y)) => e
 }
 
 ---
@@ -111,4 +148,12 @@ val x = y match {
       (case_block
         (case_clause
           (capture_pattern (identifier) (case_class_pattern (type_identifier) (number)))
-          (identifier)))))) 
+          (identifier))
+        (case_clause
+          (capture_pattern (identifier)
+            (case_class_pattern (type_identifier)
+              (capture_pattern (identifier)
+                (tuple_pattern
+                  (capture_pattern (identifier) (identifier))
+                  (typed_pattern (wildcard) (type_identifier))))))
+          (identifier))))))