Corrected parser: incomplete code should never cause brace disbalance

Fixed KT-7539 fq name inserted when completing nested traits name

 #KT-7539

compiler/testData/psi/DefaultKeyword.txt

@@ -250,58 +250,63 @@ JetFile: DefaultKeyword.kt
         PsiWhiteSpace('\n')
         OBJECT_DECLARATION_NAME
           PsiErrorElement:Name expected
-            PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n\n')
-      CLASS
-        PsiElement(class)('class')
-        PsiWhiteSpace(' ')
-        PsiElement(IDENTIFIER)('A')
-        PsiWhiteSpace(' ')
-        CLASS_BODY
-          PsiElement(LBRACE)('{')
-          PsiWhiteSpace('\n    ')
-          OBJECT_DECLARATION
-            MODIFIER_LIST
-              PsiElement(companion)('companion')
-              PsiWhiteSpace(' ')
-              PsiElement(public)('public')
-              PsiWhiteSpace(' ')
-              PsiElement(final)('final')
-            PsiWhiteSpace(' ')
-            PsiElement(object)('object')
-          PsiWhiteSpace('\n')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n\n')
-      CLASS
-        PsiComment(EOL_COMMENT)('//should be error')
-        PsiWhiteSpace('\n')
+            <empty list>
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('A')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      OBJECT_DECLARATION
         MODIFIER_LIST
           PsiElement(companion)('companion')
-        PsiWhiteSpace(' ')
-        PsiElement(class)('class')
-        PsiErrorElement:Name expected
-          <empty list>
-        PsiWhiteSpace(' ')
-        CLASS_BODY
-          PsiElement(LBRACE)('{')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n\n')
-      PROPERTY
-        PsiComment(EOL_COMMENT)('//should be error')
-        PsiWhiteSpace('\n')
-        PsiElement(val)('val')
-        PsiWhiteSpace(' ')
-        PsiElement(IDENTIFIER)('t')
-        PsiWhiteSpace(' ')
-        PsiElement(EQ)('=')
-        PsiWhiteSpace(' ')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('companion')
-        PsiWhiteSpace(' ')
-        PsiErrorElement:Property getter or setter expected
-          PsiElement(object)('object')
           PsiWhiteSpace(' ')
-          PsiElement(LBRACE)('{')
+          PsiElement(public)('public')
+          PsiWhiteSpace(' ')
+          PsiElement(final)('final')
+        PsiWhiteSpace(' ')
+        PsiElement(object)('object')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiComment(EOL_COMMENT)('//should be error')
+    PsiWhiteSpace('\n')
+    MODIFIER_LIST
+      PsiElement(companion)('companion')
+    PsiWhiteSpace(' ')
+    PsiElement(class)('class')
+    PsiErrorElement:Name expected
+      <empty list>
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  PROPERTY
+    PsiComment(EOL_COMMENT)('//should be error')
+    PsiWhiteSpace('\n')
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('t')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    REFERENCE_EXPRESSION
+      PsiElement(IDENTIFIER)('companion')
+    PsiWhiteSpace(' ')
+    PsiErrorElement:Property getter or setter expected
+      PsiElement(object)('object')
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n\n')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')

compiler/testData/psi/FunctionLiterals_ERR.txt

@@ -504,12 +504,9 @@ JetFile: FunctionLiterals_ERR.kt
             PsiWhiteSpace(' ')
             VALUE_PARAMETER
               PsiErrorElement:Expecting parameter name
-                PsiElement(RBRACE)('}')
-            PsiErrorElement:Expecting '->' or ','
-              <empty list>
-          PsiWhiteSpace('\n')
+                <empty list>
           BLOCK
             <empty list>
           PsiElement(RBRACE)('}')
-      PsiErrorElement:Expecting '}'
-        <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/ParameterType_ERR.txt

@@ -43,11 +43,13 @@ JetFile: ParameterType_ERR.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace(' ')
+      PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
   FUN
     PsiElement(fun)('fun')
@@ -74,10 +76,12 @@ JetFile: ParameterType_ERR.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
   FUN
     PsiElement(fun)('fun')

compiler/testData/psi/PropertiesFollowedByInitializers.txt

@@ -259,7 +259,11 @@ JetFile: PropertiesFollowedByInitializers.kt
           PsiElement(RBRACKET)(']')
           PsiWhiteSpace(' ')
           PsiElement(abstract)('abstract')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace(' ')
+      FUN
+        PsiErrorElement:Expecting member declaration
+          <empty list>
+        BLOCK
           PsiElement(LBRACE)('{')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n')

compiler/testData/psi/Properties_ERR.txt

@@ -6,8 +6,13 @@ JetFile: Properties_ERR.kt
     PsiWhiteSpace(' ')
     PsiErrorElement:Expecting property name or receiver type
       PsiElement(MINUS)('-')
-    PsiWhiteSpace(' ')
     PsiErrorElement:Property getter or setter expected
+      <empty list>
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
@@ -15,8 +20,13 @@ JetFile: Properties_ERR.kt
     PsiElement(var)('var')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('f')
-    PsiWhiteSpace(' ')
     PsiErrorElement:Property getter or setter expected
+      <empty list>
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
@@ -159,10 +169,12 @@ JetFile: Properties_ERR.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n   ')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
@@ -209,6 +221,8 @@ JetFile: Properties_ERR.kt
       PsiElement(get)('get')
       PsiElement(LPAR)('(')
       PsiElement(RPAR)(')')
-      PsiWhiteSpace(' ')
       PsiErrorElement:Expecting function body
-        PsiElement(MINUS)('-')
+        <empty list>
+    PsiWhiteSpace(' ')
+    PsiErrorElement:Property getter or setter expected
+      PsiElement(MINUS)('-')

compiler/testData/psi/RootPackage.txt

@@ -18,114 +18,116 @@ JetFile: RootPackage.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(package)('package')
   PsiWhiteSpace(' ')
-  MODIFIER_LIST
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foo')
-            PsiElement(DOT)('.')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('bar')
-  PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiWhiteSpace('\n  ')
   FUN
-    PsiElement(fun)('fun')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('foo')
-    VALUE_PARAMETER_LIST
-      PsiElement(LPAR)('(')
-      PsiElement(RPAR)(')')
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
     PsiWhiteSpace(' ')
     BLOCK
       PsiElement(LBRACE)('{')
-      PsiWhiteSpace('\n    ')
-      DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
-          DOT_QUALIFIED_EXPRESSION
-            ROOT_PACKAGE
-              PsiElement(package)('package')
-            PsiElement(DOT)('.')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('foo')
-          PsiElement(DOT)('.')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('X')
-      PsiWhiteSpace('\n    ')
-      DOT_QUALIFIED_EXPRESSION
-        DOT_QUALIFIED_EXPRESSION
-          DOT_QUALIFIED_EXPRESSION
-            ROOT_PACKAGE
-              PsiElement(package)('package')
-            PsiElement(DOT)('.')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('foo')
-          PsiElement(DOT)('.')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('bar')
-        PsiElement(DOT)('.')
-        CALL_EXPRESSION
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('X')
-          VALUE_ARGUMENT_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-      PsiWhiteSpace('\n    ')
-      WHEN
-        PsiElement(when)('when')
+      PsiWhiteSpace('\n  ')
+      FUN
+        PsiElement(fun)('fun')
         PsiWhiteSpace(' ')
-        PsiElement(LPAR)('(')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('e')
-        PsiElement(RPAR)(')')
+        PsiElement(IDENTIFIER)('foo')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
-        PsiElement(LBRACE)('{')
-        PsiWhiteSpace('\n      ')
-        WHEN_ENTRY
-          WHEN_CONDITION_IS_PATTERN
-            PsiElement(is)('is')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                USER_TYPE
-                  USER_TYPE
-                    PsiElement(package)('package')
-                    PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('foo')
-                  PsiElement(DOT)('.')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('bar')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n    ')
+          DOT_QUALIFIED_EXPRESSION
+            DOT_QUALIFIED_EXPRESSION
+              DOT_QUALIFIED_EXPRESSION
+                ROOT_PACKAGE
+                  PsiElement(package)('package')
                 PsiElement(DOT)('.')
                 REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('X')
-                TYPE_ARGUMENT_LIST
-                  PsiElement(LT)('<')
-                  TYPE_PROJECTION
-                    TYPE_REFERENCE
+                  PsiElement(IDENTIFIER)('foo')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+            PsiElement(DOT)('.')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('X')
+          PsiWhiteSpace('\n    ')
+          DOT_QUALIFIED_EXPRESSION
+            DOT_QUALIFIED_EXPRESSION
+              DOT_QUALIFIED_EXPRESSION
+                ROOT_PACKAGE
+                  PsiElement(package)('package')
+                PsiElement(DOT)('.')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('bar')
+            PsiElement(DOT)('.')
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('X')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+          PsiWhiteSpace('\n    ')
+          WHEN
+            PsiElement(when)('when')
+            PsiWhiteSpace(' ')
+            PsiElement(LPAR)('(')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('e')
+            PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace('\n      ')
+            WHEN_ENTRY
+              WHEN_CONDITION_IS_PATTERN
+                PsiElement(is)('is')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    USER_TYPE
                       USER_TYPE
                         PsiElement(package)('package')
                         PsiElement(DOT)('.')
                         REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Y')
-                  PsiElement(GT)('>')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            PsiElement(LBRACE)('{')
+                          PsiElement(IDENTIFIER)('foo')
+                      PsiElement(DOT)('.')
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('bar')
+                    PsiElement(DOT)('.')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('X')
+                    TYPE_ARGUMENT_LIST
+                      PsiElement(LT)('<')
+                      TYPE_PROJECTION
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            PsiElement(package)('package')
+                            PsiElement(DOT)('.')
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('Y')
+                      PsiElement(GT)('>')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
+              BLOCK
+                PsiElement(LBRACE)('{')
+                PsiElement(RBRACE)('}')
+            PsiWhiteSpace('\n    ')
             PsiElement(RBRACE)('}')
-        PsiWhiteSpace('\n    ')
-        PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n  ')
-      PsiElement(RBRACE)('}')
-  PsiWhiteSpace('\n')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+          PsiWhiteSpace('\n  ')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/functionReceivers/FunctionsWithFunctionReceiversRecovery.txt

@@ -534,67 +534,69 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
-  MODIFIER_LIST
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
+  FUN
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('c')
+                TYPE_ARGUMENT_LIST
+                  PsiElement(LT)('<')
+                  TYPE_PROJECTION
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('t')
+                  PsiElement(GT)('>')
+              PsiElement(DOT)('.')
+              PsiWhiteSpace('\n\n')
+              PsiComment(EOL_COMMENT)('//-----------')
+              PsiWhiteSpace('\n')
+              PsiErrorElement:Expecting type name
+                PsiElement(class)('class')
+      PsiWhiteSpace(' ')
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
             USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('c')
+                PsiElement(IDENTIFIER)('A')
               TYPE_ARGUMENT_LIST
                 PsiElement(LT)('<')
                 TYPE_PROJECTION
                   TYPE_REFERENCE
                     USER_TYPE
                       REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('t')
+                        PsiElement(IDENTIFIER)('X')
                 PsiElement(GT)('>')
-            PsiElement(DOT)('.')
-            PsiWhiteSpace('\n\n')
-            PsiComment(EOL_COMMENT)('//-----------')
-            PsiWhiteSpace('\n')
-            PsiErrorElement:Expecting type name
-              PsiElement(class)('class')
-    PsiWhiteSpace(' ')
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('A')
-            TYPE_ARGUMENT_LIST
-              PsiElement(LT)('<')
-              TYPE_PROJECTION
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('X')
-              PsiElement(GT)('>')
-  PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiWhiteSpace('\n    ')
-  FUN
-    PsiElement(fun)('fun')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('foo')
-    TYPE_PARAMETER_LIST
-      PsiElement(LT)('<')
-      TYPE_PARAMETER
-        PsiElement(IDENTIFIER)('Y')
-      PsiElement(GT)('>')
-    VALUE_PARAMETER_LIST
-      PsiElement(LPAR)('(')
-      PsiElement(RPAR)(')')
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
     PsiWhiteSpace(' ')
     BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            PsiElement(IDENTIFIER)('Y')
+          PsiElement(GT)('>')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n    ')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')
-  PsiWhiteSpace('\n')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
   FUN
     PsiElement(fun)('fun')

compiler/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.txt

@@ -443,21 +443,23 @@ JetFile: PropertiesWithFunctionReceivers.kt
         PsiElement(LBRACE)('{')
         PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n   ')
-  MODIFIER_LIST
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('dfget')
-      VALUE_ARGUMENT_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-  PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+  FUN
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('dfget')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
   PROPERTY
     PsiElement(val)('val')
@@ -518,18 +520,20 @@ JetFile: PropertiesWithFunctionReceivers.kt
         PsiElement(LBRACE)('{')
         PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n   ')
-  MODIFIER_LIST
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('set')
-      VALUE_ARGUMENT_LIST
-        PsiElement(LPAR)('(')
-        PsiElement(RPAR)(')')
-  PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+  FUN
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('set')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/functionReceivers/PropertiesWithFunctionReceiversRecovery.txt

@@ -29,7 +29,11 @@ JetFile: PropertiesWithFunctionReceiversRecovery.kt
       PsiElement(LT)('<')
       PsiElement(IDENTIFIER)('P')
       PsiElement(GT)('>')
-      PsiWhiteSpace(' ')
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace(' ')
       PsiElement(RBRACE)('}')
@@ -258,8 +262,13 @@ JetFile: PropertiesWithFunctionReceiversRecovery.kt
       PsiElement(RPAR)(')')
     PsiElement(DOT)('.')
     PsiElement(IDENTIFIER)('foo')
-    PsiWhiteSpace(' ')
     PsiErrorElement:Property getter or setter expected
+      <empty list>
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')

compiler/testData/psi/greatSyntacticShift/functionTypes.txt

@@ -14,24 +14,26 @@ JetFile: functionTypes.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(package)('package')
   PsiWhiteSpace(' ')
-  MODIFIER_LIST
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('n')
-  PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiWhiteSpace('\n  ')
-  CLASS
-    PsiElement(class)('class')
+  FUN
+    MODIFIER_LIST
+      ANNOTATION_ENTRY
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('n')
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
     PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('B')
-  PsiWhiteSpace('\n')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
+      CLASS
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('B')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
   CLASS
     MODIFIER_LIST

compiler/testData/psi/namelessObjectAsEnumMember.txt

@@ -32,6 +32,5 @@ JetFile: namelessObjectAsEnumMember.kt
         PsiWhiteSpace('\n')
         OBJECT_DECLARATION_NAME
           PsiErrorElement:Name expected
-            PsiElement(RBRACE)('}')
-      PsiErrorElement:Expecting '}' to close enum class body
-        <empty list>
+            <empty list>
+      PsiElement(RBRACE)('}')

compiler/testData/psi/packages/PackageBlockFirst.txt

@@ -5,32 +5,34 @@ JetFile: PackageBlockFirst.kt
     REFERENCE_EXPRESSION
       PsiElement(IDENTIFIER)('foobar')
   PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiWhiteSpace('\n  ')
-  PROPERTY
-    PsiElement(val)('val')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('a')
-    PsiWhiteSpace(' ')
-    PsiElement(EQ)('=')
-    PsiWhiteSpace(' ')
-    INTEGER_CONSTANT
-      PsiElement(INTEGER_LITERAL)('1')
-  PsiWhiteSpace('\n  ')
-  PROPERTY
-    PsiElement(val)('val')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('b')
-    PsiWhiteSpace(' ')
-    PsiElement(EQ)('=')
-    PsiWhiteSpace(' ')
-    DOT_QUALIFIED_EXPRESSION
-      REFERENCE_EXPRESSION
-        PsiElement(IDENTIFIER)('foobar')
-      PsiElement(DOT)('.')
-      REFERENCE_EXPRESSION
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
         PsiElement(IDENTIFIER)('a')
-  PsiWhiteSpace('\n')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        INTEGER_CONSTANT
+          PsiElement(INTEGER_LITERAL)('1')
+      PsiWhiteSpace('\n  ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('b')
+        PsiWhiteSpace(' ')
+        PsiElement(EQ)('=')
+        PsiWhiteSpace(' ')
+        DOT_QUALIFIED_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('foobar')
+          PsiElement(DOT)('.')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/platformTypesRecovery/WrongWordInParentheses.txt

@@ -69,7 +69,9 @@ JetFile: WrongWordInParentheses.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiWhiteSpace(' ')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(LBRACE)('{')
-  PsiErrorElement:Expecting a top level declaration
-    PsiElement(RBRACE)('}')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/CatchKeywordRBrace.kt

@@ -0,0 +1,8 @@
+fun foo() {
+    try{
+
+    }
+    catch
+}
+
+fun bar(){}

compiler/testData/psi/recovery/CatchKeywordRBrace.txt

@@ -0,0 +1,38 @@
+JetFile: CatchKeywordRBrace.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      TRY
+        PsiElement(try)('try')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n\n    ')
+          PsiElement(RBRACE)('}')
+        PsiWhiteSpace('\n    ')
+        CATCH
+          PsiElement(catch)('catch')
+          PsiErrorElement:Expecting exception variable declaration
+            <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/CloseBraceAtTopLevel.kt

@@ -0,0 +1,5 @@
+}
+
+class C
+
+fun bar(){}

compiler/testData/psi/recovery/CloseBraceAtTopLevel.txt

@@ -0,0 +1,21 @@
+JetFile: CloseBraceAtTopLevel.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('C')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/IfKeywordRBrace.kt

@@ -0,0 +1,5 @@
+fun foo() {
+    if
+}
+
+fun bar(){}

compiler/testData/psi/recovery/IfKeywordRBrace.txt

@@ -0,0 +1,34 @@
+JetFile: IfKeywordRBrace.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      IF
+        PsiElement(if)('if')
+        PsiErrorElement:Expecting a condition in parentheses '(...)'
+          <empty list>
+        PsiWhiteSpace('\n')
+        THEN
+          PsiErrorElement:Expecting an expression
+            <empty list>
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/IncompleteAccessor1.kt

@@ -0,0 +1,5 @@
+class C {
+    val v: Int get(
+}
+
+class D

compiler/testData/psi/recovery/IncompleteAccessor1.txt

@@ -0,0 +1,36 @@
+JetFile: IncompleteAccessor1.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('C')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('v')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+          PsiElement(LPAR)('(')
+          PsiErrorElement:Expecting ')'
+            <empty list>
+          PsiErrorElement:Expecting ')'
+            <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('D')

compiler/testData/psi/recovery/IncompleteAccessor2.kt

@@ -0,0 +1,5 @@
+class C {
+    val v: Int get()
+}
+
+class D

compiler/testData/psi/recovery/IncompleteAccessor2.txt

@@ -0,0 +1,35 @@
+JetFile: IncompleteAccessor2.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('C')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('v')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Int')
+        PsiWhiteSpace(' ')
+        PROPERTY_ACCESSOR
+          PsiElement(get)('get')
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+          PsiErrorElement:Expecting function body
+            <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('D')

compiler/testData/psi/recovery/IncompleteClassDeclaration.kt

@@ -0,0 +1,5 @@
+class Outer {
+    class Inner(
+}
+
+class Next

compiler/testData/psi/recovery/IncompleteClassDeclaration.txt

@@ -0,0 +1,27 @@
+JetFile: IncompleteClassDeclaration.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Outer')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('Inner')
+        PRIMARY_CONSTRUCTOR
+          VALUE_PARAMETER_LIST
+            PsiElement(LPAR)('(')
+            PsiErrorElement:Expecting ')'
+              <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Next')

compiler/testData/psi/recovery/IncompleteClassTypeParameters.kt

@@ -0,0 +1,5 @@
+class Outer {
+    class Inner<T
+}
+
+class Next

compiler/testData/psi/recovery/IncompleteClassTypeParameters.txt

@@ -0,0 +1,28 @@
+JetFile: IncompleteClassTypeParameters.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Outer')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('Inner')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            PsiElement(IDENTIFIER)('T')
+          PsiErrorElement:Missing '>'
+            <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Next')

compiler/testData/psi/recovery/IncompleteForRBrace.kt

@@ -0,0 +1,5 @@
+fun foo() {
+    for(
+}
+
+fun bar(){}

compiler/testData/psi/recovery/IncompleteForRBrace.txt

@@ -0,0 +1,35 @@
+JetFile: IncompleteForRBrace.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FOR
+        PsiElement(for)('for')
+        PsiElement(LPAR)('(')
+        PsiWhiteSpace('\n')
+        VALUE_PARAMETER
+          PsiErrorElement:Expecting a variable name
+            <empty list>
+        BODY
+          <empty list>
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/IncompleteFun.kt

@@ -0,0 +1,5 @@
+fun {
+    x()
+}
+
+fun bar(){}

compiler/testData/psi/recovery/IncompleteFun.txt

@@ -0,0 +1,30 @@
+JetFile: IncompleteFun.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiErrorElement:Expecting function name or receiver type
+      <empty list>
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('x')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/IncompleteFunDeclaration.kt

@@ -0,0 +1,5 @@
+class Outer {
+    fun foo(
+}
+
+class Next

compiler/testData/psi/recovery/IncompleteFunDeclaration.txt

@@ -0,0 +1,26 @@
+JetFile: IncompleteFunDeclaration.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Outer')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiErrorElement:Expecting ')'
+            <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Next')

compiler/testData/psi/recovery/IncompleteFunTypeParameters.kt

@@ -0,0 +1,5 @@
+class Outer {
+    fun <T
+}
+
+class Next

compiler/testData/psi/recovery/IncompleteFunTypeParameters.txt

@@ -0,0 +1,27 @@
+JetFile: IncompleteFunTypeParameters.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Outer')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            PsiElement(IDENTIFIER)('T')
+          PsiErrorElement:Missing '>'
+            <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Next')

compiler/testData/psi/recovery/IncompleteTypeParameters.kt

@@ -0,0 +1,5 @@
+class Outer {
+    fun <in
+}
+
+class Next

compiler/testData/psi/recovery/IncompleteTypeParameters.txt

@@ -0,0 +1,28 @@
+JetFile: IncompleteTypeParameters.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Outer')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            MODIFIER_LIST
+              PsiElement(in)('in')
+            PsiErrorElement:Type parameter name expected
+              <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Next')

compiler/testData/psi/recovery/IncompleteTypeRefWithPackageKeyword.kt

@@ -0,0 +1,8 @@
+fun foo() {
+    val v: package
+}
+
+fun bar() {
+}
+
+

compiler/testData/psi/recovery/IncompleteTypeRefWithPackageKeyword.txt

@@ -0,0 +1,40 @@
+JetFile: IncompleteTypeRefWithPackageKeyword.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('v')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            PsiElement(package)('package')
+            PsiErrorElement:Expecting '.'
+              <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('bar')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/IncompleteValTypeParameters.kt

@@ -0,0 +1,7 @@
+class C {
+    val <T
+}
+
+class D
+
+

compiler/testData/psi/recovery/IncompleteValTypeParameters.txt

@@ -0,0 +1,27 @@
+JetFile: IncompleteValTypeParameters.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('C')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            PsiElement(IDENTIFIER)('T')
+          PsiErrorElement:Missing '>'
+            <empty list>
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('D')

compiler/testData/psi/recovery/IncompleteWhenElse.kt

@@ -0,0 +1,9 @@
+class C {
+    fun foo() {
+        when {
+            1 -> foo()
+            else { doIt() }
+    }
+
+    fun bar(){}
+}}

compiler/testData/psi/recovery/IncompleteWhenElse.txt

@@ -0,0 +1,79 @@
+JetFile: IncompleteWhenElse.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('C')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      FUN
+        PsiElement(fun)('fun')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('foo')
+        VALUE_PARAMETER_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n        ')
+          WHEN
+            PsiElement(when)('when')
+            PsiWhiteSpace(' ')
+            PsiElement(LBRACE)('{')
+            PsiWhiteSpace('\n            ')
+            WHEN_ENTRY
+              WHEN_CONDITION_WITH_EXPRESSION
+                INTEGER_CONSTANT
+                  PsiElement(INTEGER_LITERAL)('1')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
+              CALL_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+                VALUE_ARGUMENT_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+            PsiWhiteSpace('\n            ')
+            WHEN_ENTRY
+              PsiElement(else)('else')
+              PsiErrorElement:Expecting '->'
+                <empty list>
+            PsiWhiteSpace(' ')
+            WHEN_ENTRY
+              WHEN_CONDITION_WITH_EXPRESSION
+                FUNCTION_LITERAL_EXPRESSION
+                  FUNCTION_LITERAL
+                    PsiElement(LBRACE)('{')
+                    PsiWhiteSpace(' ')
+                    BLOCK
+                      CALL_EXPRESSION
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('doIt')
+                        VALUE_ARGUMENT_LIST
+                          PsiElement(LPAR)('(')
+                          PsiElement(RPAR)(')')
+                    PsiWhiteSpace(' ')
+                    PsiElement(RBRACE)('}')
+              PsiErrorElement:Expecting '->'
+                <empty list>
+            PsiWhiteSpace('\n    ')
+            PsiElement(RBRACE)('}')
+          PsiWhiteSpace('\n\n    ')
+          FUN
+            PsiElement(fun)('fun')
+            PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('bar')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            BLOCK
+              PsiElement(LBRACE)('{')
+              PsiElement(RBRACE)('}')
+          PsiWhiteSpace('\n')
+          PsiElement(RBRACE)('}')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/recovery/IncompleteWhere.kt

@@ -0,0 +1,5 @@
+class Outer {
+    class Inner<T> where
+}
+
+class Next

compiler/testData/psi/recovery/IncompleteWhere.txt

@@ -0,0 +1,35 @@
+JetFile: IncompleteWhere.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Outer')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('Inner')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            PsiElement(IDENTIFIER)('T')
+          PsiElement(GT)('>')
+        PsiWhiteSpace(' ')
+        PsiElement(where)('where')
+        PsiWhiteSpace('\n')
+        TYPE_CONSTRAINT_LIST
+          TYPE_CONSTRAINT
+            PsiErrorElement:Expecting type parameter name
+              <empty list>
+            TYPE_REFERENCE
+              <empty list>
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Next')

compiler/testData/psi/recovery/IncompleteWhere2.kt

@@ -0,0 +1,5 @@
+class Outer {
+    class Inner<T> where T
+}
+
+class Next

compiler/testData/psi/recovery/IncompleteWhere2.txt

@@ -0,0 +1,39 @@
+JetFile: IncompleteWhere2.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Outer')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CLASS
+        PsiElement(class)('class')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('Inner')
+        TYPE_PARAMETER_LIST
+          PsiElement(LT)('<')
+          TYPE_PARAMETER
+            PsiElement(IDENTIFIER)('T')
+          PsiElement(GT)('>')
+        PsiWhiteSpace(' ')
+        PsiElement(where)('where')
+        PsiWhiteSpace(' ')
+        TYPE_CONSTRAINT_LIST
+          TYPE_CONSTRAINT
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('T')
+            PsiErrorElement:Expecting ':' before the upper bound
+              <empty list>
+            PsiWhiteSpace('\n')
+            TYPE_REFERENCE
+              PsiErrorElement:Type expected
+                <empty list>
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Next')

compiler/testData/psi/recovery/InvalidCharAfterPropertyName.kt

@@ -0,0 +1,7 @@
+class C {
+    val prop: XX$<caret> = run {
+
+    }
+
+    interface I
+}

compiler/testData/psi/recovery/InvalidCharAfterPropertyName.txt

@@ -0,0 +1,45 @@
+JetFile: InvalidCharAfterPropertyName.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  CLASS
+    PsiElement(class)('class')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('C')
+    PsiWhiteSpace(' ')
+    CLASS_BODY
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      PROPERTY
+        PsiElement(val)('val')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('prop')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('XX')
+        PsiErrorElement:Property getter or setter expected
+          PsiElement(BAD_CHARACTER)('$')
+          PsiElement(LT)('<')
+          PsiElement(IDENTIFIER)('caret')
+          PsiElement(GT)('>')
+          PsiWhiteSpace(' ')
+          PsiElement(EQ)('=')
+          PsiWhiteSpace(' ')
+          PsiElement(IDENTIFIER)('run')
+      PsiWhiteSpace(' ')
+      FUN
+        PsiErrorElement:Expecting member declaration
+          <empty list>
+        BLOCK
+          PsiElement(LBRACE)('{')
+          PsiWhiteSpace('\n\n    ')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n    ')
+      CLASS
+        PsiElement(interface)('interface')
+        PsiWhiteSpace(' ')
+        PsiElement(IDENTIFIER)('I')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')