New syntax fro patterns

idea/testData/psi/AttributesOnPatterns.jet

@@ -1,7 +1,9 @@
 fun foo() {
 
     when (e) {
-      is [a] =2 => d
+      is [a] val a => d
+      is [a] val a is foo => d
+      is [a] * => d
       is [a] 2 => d
       is [a] T => d
       is [a] T @ () => d

idea/testData/psi/AttributesOnPatterns.txt

@@ -27,7 +27,7 @@ JetFile: AttributesOnPatterns.jet
             WHEN_CONDITION
               PsiElement(is)('is')
               PsiWhiteSpace(' ')
-              EXPRESSION_PATTERN
+              BINDING_PATTERN
                 ATTRIBUTE_ANNOTATION
                   PsiElement(LBRACKET)('[')
                   ATTRIBUTE
@@ -37,9 +37,61 @@ JetFile: AttributesOnPatterns.jet
                           PsiElement(IDENTIFIER)('a')
                   PsiElement(RBRACKET)(']')
                 PsiWhiteSpace(' ')
-                PsiElement(EQ)('=')
-                INTEGER_CONSTANT
-                  PsiElement(INTEGER_LITERAL)('2')
+                PsiElement(val)('val')
+                PsiWhiteSpace(' ')
+                PsiElement(IDENTIFIER)('a')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('d')
+          PsiWhiteSpace('\n      ')
+          WHEN_ENTRY
+            WHEN_CONDITION
+              PsiElement(is)('is')
+              PsiWhiteSpace(' ')
+              BINDING_PATTERN
+                ATTRIBUTE_ANNOTATION
+                  PsiElement(LBRACKET)('[')
+                  ATTRIBUTE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                  PsiElement(RBRACKET)(']')
+                PsiWhiteSpace(' ')
+                PsiElement(val)('val')
+                PsiWhiteSpace(' ')
+                PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                PsiElement(is)('is')
+                PsiWhiteSpace(' ')
+                TYPE_PATTERN
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('foo')
+            PsiWhiteSpace(' ')
+            PsiElement(DOUBLE_ARROW)('=>')
+            PsiWhiteSpace(' ')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('d')
+          PsiWhiteSpace('\n      ')
+          WHEN_ENTRY
+            WHEN_CONDITION
+              PsiElement(is)('is')
+              PsiWhiteSpace(' ')
+              WILDCARD_PATTERN
+                ATTRIBUTE_ANNOTATION
+                  PsiElement(LBRACKET)('[')
+                  ATTRIBUTE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('a')
+                  PsiElement(RBRACKET)(']')
+                PsiWhiteSpace(' ')
+                PsiElement(MUL)('*')
             PsiWhiteSpace(' ')
             PsiElement(DOUBLE_ARROW)('=>')
             PsiWhiteSpace(' ')

idea/testData/psi/When.jet

@@ -26,10 +26,9 @@ fun foo() {
     is 'c' => foo
     is "sadfsa" => foo
     is """ddd""" => foo
-    is ? => foo
-    is ? is Foo => foo
-    is ?a is Foo => foo
-    is (?a is Foo, b) => foo
+    is * => foo
+    is val a is Foo => foo
+    is (val a is Foo, b) => foo
   }
   when (when(when (e) {
 
@@ -43,21 +42,22 @@ fun foo() {
 fun foo() {
   when (val a = e) {
     is Tree => c
-    is Tree @ (null, ?r) => c
+    is Tree @ (null, val r) => c
     is a @ (a, b) => c
     is a @ (a, b) => c
     is a.a @ (a, b) => c
     is a.a @ (foo = a, bar = b) => c
     is namespace.a.a @ (a, b) => c
-    is a @ (?a is T, b) => c
+    is a @ (val a is T, b) => c
     is a @ (b, 1) => c
     in 1..2 => dsf
     !in 2 => sd
     !is t => d
     is {(foo) : Bar} => fgpp
-    is (1, ?a is Foo, ?, ? is Foo, bar) => d
-    is (Foo, ?a in 1..2, ?, ? !is Foo, ?bar = foo.bar<a>(a)) => d
+    is (1, val a is Foo, *, Foo, bar) => d
+    is (Foo, val a in 1..2, *, val _ !is Foo, val bar is foo.bar<a> @ (a)) => d
     is (Int, Int) => 2
+    is val a : Foo => 2
     else => foo
     else continue
   }
@@ -66,11 +66,11 @@ fun foo() {
 fun foo() {
   when (val a = e) {
     is Tree,
-    is Tree @ (null, ?r),
+    is Tree @ (null, val r),
     is a @ (a, b) => c
     1, foo(), bar, 2 + 3,
     is a @ (a, b) => c
-    is a.a @ (=a + 3, b) => c
+    is a.a @ (val b, b) if (b == a + 3) => c
   }
 }