Add lambda expression

Fix call expression to allow block as arguments (#21)

Update for comprehension to handle patterns

Fix for comprehension to detect assignment as an enumerator

Add access modifiers

Update trait, object and class parameter to support modifiers

Update scanner to support `with` on a new line

Update function definition/declaration to support operator naming

Update field expression to support operators as methods

Author: Stevan Milic

corpus/definitions.txt

@@ -106,7 +106,6 @@ Class definitions
 
 class C[T, U] {
 }
-
 ---
 
 (compilation_unit
@@ -127,7 +126,8 @@ class A(b: B) extends C(b || ok) {
 
 object C {
     class A
-        extends B
+        extends B[T]
+        with C[T]
 }
 
 ---
@@ -154,7 +154,10 @@ object C {
   (object_definition
     (identifier)
     (template_body
-        (class_definition (identifier) (extends_clause (type_identifier))))))
+        (class_definition (identifier) (extends_clause
+          (compound_type
+            (generic_type (type_identifier) (type_arguments (type_identifier)))
+            (generic_type (type_identifier) (type_arguments (type_identifier)))))))))
 
 =======================================
 Class definitions with parameters
@@ -181,6 +184,10 @@ implicit final sealed class Point {
   private override def getX() = 1
 }
 
+private[a] class D[T] private (x: T) {
+  private[a] def b: Byte
+}
+
 ---
 
 (compilation_unit
@@ -189,10 +196,16 @@ implicit final sealed class Point {
     (identifier)
     (template_body
       (function_definition
-        (modifiers)
+        (modifiers (access_modifier))
         (identifier)
         (parameters)
-        (integer_literal)))))
+        (integer_literal))))
+    (class_definition (modifiers (access_modifier (access_qualifier (identifier))))
+      (identifier) (type_parameters (identifier))
+      (access_modifier) (class_parameters (class_parameter (identifier) (type_identifier)))
+      (template_body (function_declaration
+        (modifiers (access_modifier (access_qualifier (identifier))))
+        (identifier) (type_identifier)))))
 
 =======================================
 Trait definitions
@@ -346,6 +359,7 @@ Function declarations
 
 class A {
   def b(c: D) : E
+  def <*[B](that: IO[B]): IO[A]
 }
 
 ---
@@ -357,7 +371,12 @@ class A {
       (function_declaration
         (identifier)
         (parameters (parameter (identifier) (type_identifier)))
-        (type_identifier)))))
+        (type_identifier))
+      (function_declaration
+        (operator_identifier)
+        (type_parameters (identifier))
+        (parameters (parameter (identifier) (generic_type (type_identifier) (type_arguments (type_identifier)))))
+        (generic_type (type_identifier) (type_arguments (type_identifier)))))))
 
 =======================================
 Function definitions

corpus/expressions.txt

@@ -7,6 +7,11 @@ class C {
     a()
     a(123)
     a(b, c)
+    a.map(x => x + 1)
+    a { 123 }
+    a { b }
+    a.map{ x => x + 1 }
+    a.exists { case ((i, _)) => i }
   }
 }
 
@@ -22,7 +27,17 @@ class C {
         (block
           (call_expression (identifier) (arguments))
           (call_expression (identifier) (arguments (integer_literal)))
-          (call_expression (identifier) (arguments (identifier) (identifier))))))))
+          (call_expression (identifier) (arguments (identifier) (identifier)))
+          (call_expression (field_expression (identifier) (identifier)) (arguments
+            (lambda_expression (identifier)
+                (infix_expression (identifier) (operator_identifier) (integer_literal)))))
+          (call_expression (identifier) (block (integer_literal)))
+          (call_expression (identifier) (block (identifier)))
+          (call_expression (field_expression (identifier) (identifier)) (block
+            (lambda_expression (identifier)
+                (infix_expression (identifier) (operator_identifier) (integer_literal)))))
+          (call_expression (field_expression (identifier) (identifier)) (case_clause
+            (tuple_pattern (tuple_pattern (identifier) (wildcard))) (identifier))))))))
 
 ===============================
 Generic functions
@@ -216,6 +231,7 @@ def matchTest(x: Int): String = x match {
   case 3 => {
     "3"
   }
+  case ((i, _)) => i
   case _ =>
     val x = "many"
     "more"
@@ -233,6 +249,7 @@ def matchTest(x: Int): String = x match {
       (case_clause (integer_literal) (string) (string))
       (case_clause (integer_literal) (string))
       (case_clause (integer_literal) (block (string)))
+      (case_clause (tuple_pattern (tuple_pattern (identifier) (wildcard))) (identifier))
       (case_clause (wildcard) (val_definition (identifier) (string)) (string))))))
 
 ===============================
@@ -403,6 +420,42 @@ object O {
       (ascription_expression (integer_literal)
         (repeated_parameter_type (type_identifier))))))
 
+================================================================================
+Lambda Expression
+================================================================================
+
+object O {
+  val l = a => a + 1
+  val b = (x: Int, y: Int) => { x * y }
+  val f = _ => 2
+  (a, b, _) => a - b
+}
+
+--------------------------------------------------------------------------------
+
+(compilation_unit
+  (object_definition (identifier)
+    (template_body (val_definition
+        (identifier) (lambda_expression
+          (identifier) (infix_expression
+            (identifier) (operator_identifier) (integer_literal))))
+      (val_definition (identifier)
+        (lambda_expression (bindings
+            (binding (identifier) (type_identifier))
+            (binding (identifier) (type_identifier)))
+          (block (infix_expression
+              (identifier) (operator_identifier) (identifier)))))
+      (val_definition (identifier)
+        (lambda_expression (identifier) (integer_literal)))
+      (lambda_expression
+        (bindings
+          (binding (identifier))
+          (binding (identifier))
+          (binding (identifier)))
+        (infix_expression (identifier)
+          (operator_identifier)
+          (identifier))))))
+
 ===============================
 Unit expressions
 ===============================
@@ -506,6 +559,7 @@ def f() = {
     x <- xs
     a = b + c
     y <- g() if d
+    (t, u) = y
   } yield {
     h(x, y)
   }
@@ -529,8 +583,9 @@ def f() = {
      (for_expression
        (enumerators
          (enumerator (identifier) (identifier))
-         (assignment_expression (identifier) (infix_expression (identifier) (operator_identifier) (identifier)))
-         (enumerator (identifier) (call_expression (identifier) (arguments)) (guard (identifier))))
+         (enumerator (identifier) (infix_expression (identifier) (operator_identifier) (identifier)))
+         (enumerator (identifier) (call_expression (identifier) (arguments)) (guard (identifier)))
+         (enumerator (tuple_pattern (identifier) (identifier)) (identifier)))
        (block (call_expression (identifier) (arguments (identifier) (identifier))))))))
 
 ===============================