Drop suppport for annotation syntax without '@' from parser

compiler/frontend/src/org/jetbrains/kotlin/parsing/JetExpressionParsing.java

@@ -33,7 +33,6 @@ import java.util.Set;
 
 import static org.jetbrains.kotlin.JetNodeTypes.*;
 import static org.jetbrains.kotlin.lexer.JetTokens.*;
-import static org.jetbrains.kotlin.parsing.JetParsing.AnnotationParsingMode.ALLOW_UNESCAPED_REGULAR_ANNOTATIONS;
 import static org.jetbrains.kotlin.parsing.JetParsing.AnnotationParsingMode.ONLY_ESCAPED_REGULAR_ANNOTATIONS;
 import static org.jetbrains.kotlin.parsing.JetParsing.DeclarationParsingMode.LOCAL;
 
@@ -846,14 +845,14 @@ public class JetExpressionParsing extends AbstractJetParsing {
         if (at(LPAR)) {
             advanceAt(LPAR);
 
-            int valPos = matchTokenStreamPredicate(new FirstBefore(new At(VAL_KEYWORD), new AtSet(RPAR, LBRACE, RBRACE, SEMICOLON, EQ)));
-            if (valPos >= 0) {
             PsiBuilder.Marker property = mark();
-                myJetParsing.parseModifierList(ALLOW_UNESCAPED_REGULAR_ANNOTATIONS);
+            myJetParsing.parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.create(EQ, RPAR));
+            if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) {
                 myJetParsing.parseProperty(true);
                 property.done(PROPERTY);
             }
             else {
+                property.rollbackTo();
                 parseExpression();
             }
 
@@ -1035,7 +1034,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
     private boolean parseLocalDeclaration() {
         PsiBuilder.Marker decl = mark();
         JetParsing.ModifierDetector detector = new JetParsing.ModifierDetector();
-        myJetParsing.parseModifierList(detector, ONLY_ESCAPED_REGULAR_ANNOTATIONS);
+        myJetParsing.parseModifierList(detector, ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.EMPTY);
 
         IElementType declType = parseLocalDeclarationRest(detector.isEnumDetected());
 
@@ -1343,9 +1342,7 @@ public class JetExpressionParsing extends AbstractJetParsing {
                 PsiBuilder.Marker parameter = mark();
 
                 if (!at(IN_KEYWORD)) {
-                    myJetParsing.parseModifierListWithUnescapedAnnotations(
+                    myJetParsing.parseModifierListWithLookForStopAt(TokenSet.create(IDENTIFIER, LPAR), TokenSet.create(IN_KEYWORD, RPAR, COLON));
-                            TokenSet.create(IDENTIFIER, LPAR), TokenSet.create(IN_KEYWORD, RPAR, COLON)
-                    );
                 }
 
                 if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) advance(); // VAL_KEYWORD or VAR_KEYWORD

compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java

@@ -196,7 +196,7 @@ public class JetParsing extends AbstractJetParsing {
          *   ;
          */
         PsiBuilder.Marker packageDirective = mark();
-        parseModifierList(ALLOW_UNESCAPED_REGULAR_ANNOTATIONS);
+        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.EMPTY);
 
         if (at(PACKAGE_KEYWORD)) {
             advance(); // PACKAGE_KEYWORD
@@ -391,7 +391,7 @@ public class JetParsing extends AbstractJetParsing {
         PsiBuilder.Marker decl = mark();
 
         ModifierDetector detector = new ModifierDetector();
-        parseModifierList(detector, ALLOW_UNESCAPED_REGULAR_ANNOTATIONS);
+        parseModifierList(detector, ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.EMPTY);
 
         IElementType keywordToken = tt();
         IElementType declType = null;
@@ -434,9 +434,10 @@ public class JetParsing extends AbstractJetParsing {
      * (modifier | annotation)*
      */
     boolean parseModifierList(
-            @NotNull AnnotationParsingMode annotationParsingMode
+            @NotNull AnnotationParsingMode annotationParsingMode,
+            @Nullable TokenSet noModifiersBefore
     ) {
-        return parseModifierList(null, annotationParsingMode);
+        return parseModifierList(null, annotationParsingMode, noModifiersBefore);
     }
 
     /**
@@ -446,7 +447,8 @@ public class JetParsing extends AbstractJetParsing {
      */
     boolean parseModifierList(
             @Nullable Consumer<IElementType> tokenConsumer,
-            @NotNull AnnotationParsingMode annotationParsingMode
+            @NotNull AnnotationParsingMode annotationParsingMode,
+            @Nullable TokenSet noModifiersBefore
     ) {
         PsiBuilder.Marker list = mark();
         boolean empty = true;
@@ -458,7 +460,7 @@ public class JetParsing extends AbstractJetParsing {
             if (at(AT) && annotationParsingMode.allowAnnotations) {
                 parseAnnotationOrList(annotationParsingMode);
             }
-            else if (tryParseModifier(tokenConsumer)) {
+            else if (tryParseModifier(tokenConsumer, noModifiersBefore)) {
                 // modifier advanced
             }
             else if (annotationParsingMode.allowShortAnnotations && at(IDENTIFIER)) {
@@ -479,10 +481,12 @@ public class JetParsing extends AbstractJetParsing {
         return !empty;
     }
 
-    private boolean tryParseModifier(@Nullable Consumer<IElementType> tokenConsumer) {
+    private boolean tryParseModifier(@Nullable Consumer<IElementType> tokenConsumer, @Nullable TokenSet noModifiersBefore) {
         PsiBuilder.Marker marker = mark();
 
         if (atSet(MODIFIER_KEYWORDS)) {
+            IElementType lookahead = lookahead(1);
+            if (noModifiersBefore == null || lookahead != null && !noModifiersBefore.contains(lookahead)) {
                 IElementType tt = tt();
                 if (tokenConsumer != null) {
                     tokenConsumer.consume(tt);
@@ -491,6 +495,7 @@ public class JetParsing extends AbstractJetParsing {
                 marker.collapse(tt);
                 return true;
             }
+        }
 
         marker.rollbackTo();
         return false;
@@ -805,7 +810,8 @@ public class JetParsing extends AbstractJetParsing {
         PsiBuilder.Marker beforeConstructorModifiers = mark();
         PsiBuilder.Marker primaryConstructorMarker = mark();
         boolean hasConstructorModifiers = parseModifierList(
-                declarationParsingMode != LOCAL ? PRIMARY_CONSTRUCTOR_MODIFIER_LIST : PRIMARY_CONSTRUCTOR_MODIFIER_LIST_LOCAL
+                declarationParsingMode != LOCAL ? PRIMARY_CONSTRUCTOR_MODIFIER_LIST : PRIMARY_CONSTRUCTOR_MODIFIER_LIST_LOCAL,
+                TokenSet.EMPTY
         );
 
         // Some modifiers found, but no parentheses following: class has already ended, and we are looking at something else
@@ -945,7 +951,7 @@ public class JetParsing extends AbstractJetParsing {
     private ParseEnumEntryResult parseEnumEntry() {
         PsiBuilder.Marker entry = mark();
 
-        parseModifierListWithStopAt(TokenSet.create(COMMA, SEMICOLON, RBRACE), ONLY_ESCAPED_REGULAR_ANNOTATIONS);
+        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.create(COMMA, COLON, SEMICOLON, RBRACE));
 
         if (!atSet(SOFT_KEYWORDS_AT_MEMBER_START) && at(IDENTIFIER)) {
             PsiBuilder.Marker nameAsDeclaration = mark();
@@ -1052,7 +1058,7 @@ public class JetParsing extends AbstractJetParsing {
         PsiBuilder.Marker decl = mark();
 
         ModifierDetector detector = new ModifierDetector();
-        parseModifierList(detector, ALLOW_UNESCAPED_REGULAR_ANNOTATIONS_AT_MEMBER_MODIFIER_LIST);
+        parseModifierList(detector, ALLOW_UNESCAPED_REGULAR_ANNOTATIONS_AT_MEMBER_MODIFIER_LIST, TokenSet.EMPTY);
 
         IElementType declType = parseMemberDeclarationRest(detector.isEnumDetected(), detector.isDefaultDetected());
 
@@ -1177,33 +1183,6 @@ public class JetParsing extends AbstractJetParsing {
         mark.done(CONSTRUCTOR_DELEGATION_REFERENCE);
     }
 
-    /*
-     * initializer
-     *   : annotations constructorInvocation // type parameters may (must?) be omitted
-     *   ;
-     */
-    private void parseInitializer() {
-        PsiBuilder.Marker initializer = mark();
-        parseAnnotations(ONLY_ESCAPED_REGULAR_ANNOTATIONS);
-
-        IElementType type;
-        if (atSet(TYPE_REF_FIRST)) {
-            PsiBuilder.Marker reference = mark();
-            parseTypeRef();
-            reference.done(CONSTRUCTOR_CALLEE);
-            type = DELEGATOR_SUPER_CALL;
-        }
-        else {
-            errorWithRecovery("Expecting constructor call (<class-name>(...))",
-                              TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST, TokenSet.create(RBRACE, LBRACE, COMMA, SEMICOLON)));
-            initializer.drop();
-            return;
-        }
-        myExpressionParsing.parseValueArgumentList();
-
-        initializer.done(type);
-    }
-
     /*
      * typeAlias
      *   : modifiers "typealias" SimpleName (typeParameters typeConstraints)? "=" type
@@ -1248,12 +1227,8 @@ public class JetParsing extends AbstractJetParsing {
     }
 
     public IElementType parseProperty(boolean local) {
-        if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) {
+        assert (at(VAL_KEYWORD) || at(VAR_KEYWORD));
-            advance(); // VAL_KEYWORD or VAR_KEYWORD
+        advance();
-        }
-        else {
-            errorAndAdvance("Expecting 'val' or 'var'");
-        }
 
         boolean typeParametersDeclared = at(LT) && parseTypeParameterList(TokenSet.create(IDENTIFIER, EQ, COLON, SEMICOLON));
 
@@ -1359,7 +1334,7 @@ public class JetParsing extends AbstractJetParsing {
                 }
                 PsiBuilder.Marker property = mark();
 
-                parseModifierListWithUnescapedAnnotations(TokenSet.create(COMMA, RPAR, COLON, IN_KEYWORD, EQ));
+                parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.create(COMMA, RPAR, COLON, IN_KEYWORD, EQ));
 
                 expect(IDENTIFIER, "Expecting a name", recoverySet);
 
@@ -1391,7 +1366,7 @@ public class JetParsing extends AbstractJetParsing {
     private boolean parsePropertyGetterOrSetter() {
         PsiBuilder.Marker getterOrSetter = mark();
 
-        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS);
+        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.EMPTY);
 
         if (!at(GET_KEYWORD) && !at(SET_KEYWORD)) {
             getterOrSetter.rollbackTo();
@@ -1418,7 +1393,7 @@ public class JetParsing extends AbstractJetParsing {
         if (setter) {
             PsiBuilder.Marker parameterList = mark();
             PsiBuilder.Marker setterParameter = mark();
-            parseModifierListWithUnescapedAnnotations(TokenSet.create(RPAR, COMMA, COLON));
+            parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.create(COMMA, COLON, RPAR));
             expect(IDENTIFIER, "Expecting parameter name", TokenSet.create(RPAR, COLON, LBRACE, EQ));
 
             if (at(COLON)) {
@@ -1804,7 +1779,7 @@ public class JetParsing extends AbstractJetParsing {
 
         PsiBuilder.Marker mark = mark();
 
-        parseModifierListWithUnescapedAnnotations(TokenSet.create(COMMA, GT, COLON));
+        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, TokenSet.create(GT, COMMA, COLON));
 
         expect(IDENTIFIER, "Type parameter name expected", TokenSet.EMPTY);
 
@@ -2085,7 +2060,7 @@ public class JetParsing extends AbstractJetParsing {
 //            TokenSet stopAt = TokenSet.create(COMMA, COLON, GT);
 //            parseModifierListWithUnescapedAnnotations(MODIFIER_LIST, lookFor, stopAt);
             // Currently we do not allow annotations
-            parseModifierList(NO_ANNOTATIONS);
+            parseModifierList(NO_ANNOTATIONS, TokenSet.create(COMMA, COLON, GT));
 
             if (at(MUL)) {
                 advance(); // MUL
@@ -2109,21 +2084,9 @@ public class JetParsing extends AbstractJetParsing {
         return atGT;
     }
 
-    public void parseModifierListWithUnescapedAnnotations(TokenSet stopAt) {
+    public void parseModifierListWithLookForStopAt(TokenSet lookFor, TokenSet stopAt) {
-        parseModifierListWithLookForStopAt(TokenSet.create(IDENTIFIER), stopAt, ALLOW_UNESCAPED_REGULAR_ANNOTATIONS);
-    }
-
-    public void parseModifierListWithStopAt(TokenSet stopAt, AnnotationParsingMode mode) {
-        parseModifierListWithLookForStopAt(TokenSet.create(IDENTIFIER), stopAt, mode);
-    }
-
-    public void parseModifierListWithUnescapedAnnotations(TokenSet lookFor, TokenSet stopAt) {
-        parseModifierListWithLookForStopAt(lookFor, stopAt, ALLOW_UNESCAPED_REGULAR_ANNOTATIONS);
-    }
-
-    public void parseModifierListWithLookForStopAt(TokenSet lookFor, TokenSet stopAt, AnnotationParsingMode mode) {
         int lastId = matchTokenStreamPredicate(new LastBefore(new AtSet(lookFor), new AnnotationTargetStop(stopAt, ANNOTATION_TARGETS), false));
-        createTruncatedBuilder(lastId).parseModifierList(mode);
+        createTruncatedBuilder(lastId).parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, null);
     }
 
     private class AnnotationTargetStop extends AbstractTokenStreamPredicate {
@@ -2174,6 +2137,8 @@ public class JetParsing extends AbstractJetParsing {
         return functionType;
     }
 
+    private static final TokenSet NO_MODIFIER_BEFORE_FOR_VALUE_PARAMETER = TokenSet.create(COMMA, COLON, EQ, RPAR);
+
     /*
      * functionParameters
      *   : "(" functionParameter{","}? ")" // default values
@@ -2207,7 +2172,7 @@ public class JetParsing extends AbstractJetParsing {
                 if (isFunctionTypeContents) {
                     if (!tryParseValueParameter(typeRequired)) {
                         PsiBuilder.Marker valueParameter = mark();
-                        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS); // lazy, out, ref
+                        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, NO_MODIFIER_BEFORE_FOR_VALUE_PARAMETER); // lazy, out, ref
                         parseTypeRef();
                         closeDeclarationWithCommentBinders(valueParameter, VALUE_PARAMETER, false);
                     }
@@ -2248,7 +2213,7 @@ public class JetParsing extends AbstractJetParsing {
     private boolean parseValueParameter(boolean rollbackOnFailure, boolean typeRequired) {
         PsiBuilder.Marker parameter = mark();
 
-        parseModifierListWithUnescapedAnnotations(TokenSet.create(COMMA, RPAR));
+        parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS, NO_MODIFIER_BEFORE_FOR_VALUE_PARAMETER);
 
         if (at(VAR_KEYWORD) || at(VAL_KEYWORD)) {
             advance(); // VAR_KEYWORD | VAL_KEYWORD

compiler/frontend/src/org/jetbrains/kotlin/psi/JetProperty.java

@@ -275,7 +275,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStu
     @NotNull
     public PsiElement getValOrVarKeyword() {
         PsiElement element = findChildByType(VAL_VAR_TOKEN_SET);
-        assert element != null : "Val or var should always exist for property";
+        assert element != null : "Val or var should always exist for property" + this.getText();
         return element;
     }
 

compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt

@@ -1,9 +1,9 @@
-fun foo(<!UNRESOLVED_REFERENCE!><!SYNTAX!><!>varargs<!> <!UNUSED_PARAMETER!>f<!> : Int) {}
+fun foo(<!UNRESOLVED_REFERENCE!>@varargs<!> <!UNUSED_PARAMETER!>f<!> : Int) {}
 
 var bar : Int = 1
-  set(<!UNRESOLVED_REFERENCE!><!SYNTAX!><!>varargs<!> v) {}
+  set(<!UNRESOLVED_REFERENCE!>@varargs<!> v) {}
 
 val x : (Int) -> Int = {<!UNRESOLVED_REFERENCE!>@varargs<!> <!TYPE_MISMATCH!>x<!> <!SYNTAX!>: Int -> x<!>}
 
-class Hello(<!UNRESOLVED_REFERENCE!><!SYNTAX!><!>varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
+class Hello(<!UNRESOLVED_REFERENCE!>@varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
 }

compiler/testData/diagnostics/tests/imports/SyntaxError.kt

@@ -57,4 +57,4 @@ import a.<!SYNTAX!>%<!>.b.<!PACKAGE_CANNOT_BE_IMPORTED!>c<!>.<!SYNTAX!><!>
 import a.b.c.D.<!SYNTAX!><!>
 import a.b.c.D.E.<!SYNTAX!><!>
 
-import <!PACKAGE_CANNOT_BE_IMPORTED!>a<!><!SYNTAX!>?.<!><!UNRESOLVED_REFERENCE!><!SYNTAX!><!>b<!SYNTAX!><!><!>
+import <!PACKAGE_CANNOT_BE_IMPORTED!>a<!><!SYNTAX!>?.<!><!SYNTAX!>b<!>

compiler/testData/diagnostics/tests/recovery/namelessMembers.kt

@@ -12,6 +12,6 @@ class C {
     enum class<!SYNTAX!><!> {}
 }
 
-class C1<in<!SYNTAX!>><!><!SYNTAX!><!> {}
+class C1<<!SYNTAX!>in<!>> {}
 
 class C2(val<!SYNTAX!><!>) {}

compiler/testData/diagnostics/tests/recovery/namelessMembers.txt

@@ -31,8 +31,8 @@ public final class C {
     }
 }
 
-public final class C1</*0*/ in <no name provided>> {
+public final class C1</*0*/ <no name provided>> {
-    public constructor C1</*0*/ in <no name provided>>()
+    public constructor C1</*0*/ <no name provided>>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String

compiler/testData/diagnostics/tests/regressions/ea66984.kt

@@ -1,2 +1,2 @@
 // !DIAGNOSTICS: -NO_VALUE_FOR_PARAMETER
-class Tree<T>(<!NOT_A_CLASS!><!SYNTAX!><!>T<!> element<!SYNTAX!><!>, <!NOT_AN_ANNOTATION_CLASS!><!SYNTAX!><!>Tree<T><!> left<!SYNTAX!><!>, <!NOT_AN_ANNOTATION_CLASS!><!SYNTAX!><!>Tree<T><!> right<!SYNTAX!><!>) {}
+class Tree<<!REDECLARATION!>T<!>>(T <!SYNTAX!>element<!>, <!REDECLARATION, REDECLARATION!><!SYNTAX!><!>Tree<T><!><!SYNTAX!><!> left<!SYNTAX!><!>, <!REDECLARATION, REDECLARATION!><!SYNTAX!><!>Tree<T><!><!SYNTAX!><!> right<!SYNTAX!><!>) {}

compiler/testData/diagnostics/tests/regressions/ea66984.txt

@@ -1,7 +1,7 @@
 package
 
 public final class Tree</*0*/ T> {
-    public constructor Tree</*0*/ T>(/*0*/ @[ERROR : Not an annotation: T]() element: [ERROR : Type annotation was missing for parameter element], /*1*/ @Tree<T>() left: [ERROR : Type annotation was missing for parameter left], /*2*/ @Tree<T>() right: [ERROR : Type annotation was missing for parameter right])
+    public constructor Tree</*0*/ T>(/*0*/ T: [ERROR : Type annotation was missing for parameter T], /*1*/ <no name provided>: Tree<T>, /*2*/ left: [ERROR : Type annotation was missing for parameter left], /*3*/ <no name provided>: Tree<T>, /*4*/ right: [ERROR : Type annotation was missing for parameter right])
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String

compiler/testData/psi/DynamicSoftKeyword.txt

@@ -3,17 +3,10 @@ JetFile: DynamicSoftKeyword.kt
     <empty list>
   IMPORT_LIST
     <empty list>
-  CLASS
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('dynamic')
   PsiWhiteSpace(' ')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('dynamic')

compiler/testData/psi/EnumWithAnnotationKeyword.txt

@@ -24,23 +24,17 @@ JetFile: EnumWithAnnotationKeyword.kt
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
-  FUN
   MODIFIER_LIST
     PsiElement(enum)('enum')
     PsiWhiteSpace(' ')
     PsiElement(annotation)('annotation')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('E1')
+  PsiWhiteSpace(' ')
+  FUN
     PsiErrorElement:Expecting a top level declaration
       <empty list>
-    PsiWhiteSpace(' ')
     BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')

compiler/testData/psi/FileStart_ERR.txt

@@ -8,36 +8,15 @@ JetFile: FileStart_ERR.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(package)('package')
   PsiWhiteSpace(' ')
-  MODIFIER_LIST
+  PsiErrorElement:Expecting a top level declaration
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foo')
-            PsiElement(DOT)('.')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('bar')
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    PsiWhiteSpace('\n')
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('import')
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    PsiWhiteSpace(' ')
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
   PsiErrorElement:Expecting a top level declaration
-    <empty list>
+    PsiElement(DOT)('.')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace('\n')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('import')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('foo')

compiler/testData/psi/ParameterNameMising.txt

@@ -72,11 +72,8 @@ JetFile: ParameterNameMising.kt
     VALUE_PARAMETER_LIST
       PsiElement(LPAR)('(')
       VALUE_PARAMETER
-        MODIFIER_LIST
+        PsiErrorElement:Parameter name expected
-          PsiErrorElement:Use '@' symbol before annotations
           <empty list>
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
         TYPE_REFERENCE
           USER_TYPE
             REFERENCE_EXPRESSION
@@ -89,8 +86,6 @@ JetFile: ParameterNameMising.kt
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('String')
               PsiElement(GT)('>')
-        PsiErrorElement:Parameter name expected
-          <empty list>
         PsiWhiteSpace(' ')
         PsiElement(EQ)('=')
         PsiWhiteSpace(' ')

compiler/testData/psi/ParameterType_ERR.txt

@@ -33,14 +33,7 @@ JetFile: ParameterType_ERR.kt
         <empty list>
       PsiErrorElement:Expecting ')'
         PsiElement(LPAR)('(')
-  MODIFIER_LIST
+  PsiErrorElement:Expecting a top level declaration
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('InlineOp')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
@@ -67,14 +60,7 @@ JetFile: ParameterType_ERR.kt
         <empty list>
       PsiErrorElement:Expecting ')'
         PsiElement(LPAR)('(')
-  MODIFIER_LIST
+  PsiErrorElement:Expecting a top level declaration
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('parameter')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')

compiler/testData/psi/Properties_ERR.txt

@@ -185,17 +185,10 @@ JetFile: Properties_ERR.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(EQ)('=')
   PsiWhiteSpace(' ')
-  PROPERTY
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
   PsiWhiteSpace('\n\n')
+  PROPERTY
     PsiElement(val)('val')
     PsiWhiteSpace(' ')
     TYPE_REFERENCE

compiler/testData/psi/RootPackage.txt

@@ -20,23 +20,16 @@ JetFile: RootPackage.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(package)('package')
   PsiWhiteSpace(' ')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(IDENTIFIER)('bar')
+  PsiWhiteSpace(' ')
+  FUN
     PsiErrorElement:Expecting a top level declaration
       <empty list>
-    PsiWhiteSpace(' ')
     BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n  ')

compiler/testData/psi/SimpleModifiers.txt

@@ -15,7 +15,6 @@ JetFile: SimpleModifiers.kt
   IMPORT_LIST
     <empty list>
   PsiWhiteSpace('\n\n')
-  CLASS
   MODIFIER_LIST
     PsiElement(abstract)('abstract')
     PsiWhiteSpace('\n')
@@ -42,16 +41,11 @@ JetFile: SimpleModifiers.kt
     PsiElement(in)('in')
     PsiWhiteSpace('\n')
     PsiElement(out)('out')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace('\n')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('ref')
   PsiWhiteSpace('\n ')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('Bar')
@@ -86,20 +80,18 @@ JetFile: SimpleModifiers.kt
           PsiElement(in)('in')
           PsiWhiteSpace('\n        ')
           PsiElement(out)('out')
-          PsiErrorElement:Use '@' symbol before annotations
-            <empty list>
         PsiWhiteSpace('\n        ')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('ref')
       PsiWhiteSpace(' ')
+      PsiErrorElement:Missing '>'
         PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
   PsiWhiteSpace(' ')
-    CLASS_BODY
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       PROPERTY

compiler/testData/psi/SoftKeywords.txt

@@ -20,7 +20,6 @@ JetFile: SoftKeywords.kt
       REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('foo')
   PsiWhiteSpace('\n\n')
-  CLASS
   MODIFIER_LIST
     PsiElement(public)('public')
     PsiWhiteSpace(' ')
@@ -55,16 +54,11 @@ JetFile: SoftKeywords.kt
     PsiElement(in)('in')
     PsiWhiteSpace('\n')
     PsiElement(out)('out')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace('\n')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('ref')
   PsiWhiteSpace('\n ')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('Bar')

compiler/testData/psi/annotation/Annotations.txt

@@ -15,7 +15,6 @@ JetFile: Annotations.kt
   IMPORT_LIST
     <empty list>
   PsiWhiteSpace('\n\n')
-  CLASS
   MODIFIER_LIST
     PsiElement(abstract)('abstract')
     PsiWhiteSpace('\n')
@@ -160,16 +159,11 @@ JetFile: Annotations.kt
       PsiElement(RBRACKET)(']')
     PsiWhiteSpace('\n')
     PsiElement(out)('out')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace('\n')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('ref')
   PsiWhiteSpace('\n ')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('Bar')
@@ -324,20 +318,18 @@ JetFile: Annotations.kt
           PsiElement(in)('in')
           PsiWhiteSpace('\n')
           PsiElement(out)('out')
-          PsiErrorElement:Use '@' symbol before annotations
-            <empty list>
         PsiWhiteSpace('\n')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('ref')
       PsiWhiteSpace(' ')
+      PsiErrorElement:Missing '>'
         PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
   PsiWhiteSpace(' ')
-    CLASS_BODY
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')

compiler/testData/psi/annotation/Annotations_ERR.txt

@@ -15,7 +15,6 @@ JetFile: Annotations_ERR.kt
   IMPORT_LIST
     <empty list>
   PsiWhiteSpace('\n\n')
-  CLASS
   MODIFIER_LIST
     PsiElement(abstract)('abstract')
     PsiWhiteSpace('\n')
@@ -198,16 +197,11 @@ JetFile: Annotations_ERR.kt
       PsiElement(RBRACKET)(']')
     PsiWhiteSpace('\n')
     PsiElement(out)('out')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace('\n')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('ref')
   PsiWhiteSpace('\n ')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('Bar')
@@ -279,20 +273,18 @@ JetFile: Annotations_ERR.kt
           PsiElement(in)('in')
           PsiWhiteSpace('\n')
           PsiElement(out)('out')
-          PsiErrorElement:Use '@' symbol before annotations
-            <empty list>
         PsiWhiteSpace('\n')
-          ANNOTATION_ENTRY
-            CONSTRUCTOR_CALLEE
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
         PsiElement(IDENTIFIER)('ref')
       PsiWhiteSpace(' ')
+      PsiErrorElement:Missing '>'
         PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
   PsiWhiteSpace(' ')
-    CLASS_BODY
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')

compiler/testData/psi/annotation/ShortAnnotations.kt

@@ -21,6 +21,10 @@ class Foo {
 }
 
 fun test() {
+  when (@foo @bar(1) @buzz<T>(1) @zoo val a = 1) {
+    1 -> 1
+  }
+
   when (foo bar(1) buzz<T>(1) zoo val a = 1) {
     1 -> 1
   }

compiler/testData/psi/annotation/ShortAnnotations.txt

@@ -1,252 +1,146 @@
 JetFile: ShortAnnotations.kt
   PACKAGE_DIRECTIVE
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
     <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('foo')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
-          PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
-            INTEGER_CONSTANT
-              PsiElement(INTEGER_LITERAL)('1')
-          PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('buzz')
-              TYPE_ARGUMENT_LIST
-                PsiElement(LT)('<')
-                TYPE_PROJECTION
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('T')
-                PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
-          PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
-            INTEGER_CONSTANT
-              PsiElement(INTEGER_LITERAL)('1')
-          PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('zoo')
-    PsiWhiteSpace(' ')
-    PsiElement(package)('package')
-    PsiWhiteSpace(' ')
-    REFERENCE_EXPRESSION
-      PsiElement(IDENTIFIER)('aa')
   IMPORT_LIST
     <empty list>
-  PsiWhiteSpace('\n\n')
+  PsiErrorElement:Expecting a top level declaration
-  CLASS
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('buzz')
-              TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-                TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('zoo')
   PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(package)('package')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('aa')
+  PsiWhiteSpace('\n\n')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('foo')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('bar')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('buzz')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LT)('<')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(GT)('>')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('zoo')
+  PsiWhiteSpace(' ')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('A')
   PsiWhiteSpace('\n')
-  OBJECT_DECLARATION
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('buzz')
-              TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-                TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('zoo')
   PsiWhiteSpace(' ')
+  OBJECT_DECLARATION
     PsiElement(object)('object')
     PsiWhiteSpace(' ')
     OBJECT_DECLARATION_NAME
       PsiElement(IDENTIFIER)('B')
   PsiWhiteSpace('\n')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('buzz')
-              TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-                TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('zoo')
   PsiWhiteSpace(' ')
+  FUN
     PsiElement(fun)('fun')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('a')
@@ -258,64 +152,37 @@ JetFile: ShortAnnotations.kt
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
-  PROPERTY
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('buzz')
-              TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-                TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('zoo')
   PsiWhiteSpace(' ')
+  PROPERTY
     PsiElement(val)('val')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('c')
@@ -332,64 +199,37 @@ JetFile: ShortAnnotations.kt
     INTEGER_CONSTANT
       PsiElement(INTEGER_LITERAL)('0')
   PsiWhiteSpace('\n')
-  PROPERTY
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('buzz')
-              TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-                TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('zoo')
   PsiWhiteSpace(' ')
+  PROPERTY
     PsiElement(var)('var')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('v')
@@ -406,64 +246,37 @@ JetFile: ShortAnnotations.kt
     INTEGER_CONSTANT
       PsiElement(INTEGER_LITERAL)('0')
   PsiWhiteSpace('\n')
-  TYPEDEF
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('bar')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('buzz')
-              TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-                TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-          VALUE_ARGUMENT
+  PsiErrorElement:Expecting a top level declaration
-            INTEGER_CONSTANT
     PsiElement(INTEGER_LITERAL)('1')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
   PsiWhiteSpace(' ')
-      ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('zoo')
   PsiWhiteSpace(' ')
+  TYPEDEF
     PsiElement(typealias)('typealias')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('T')
@@ -1043,18 +856,16 @@ JetFile: ShortAnnotations.kt
         PsiElement(LPAR)('(')
         PROPERTY
           MODIFIER_LIST
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('foo')
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             PsiWhiteSpace(' ')
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -1066,10 +877,9 @@ JetFile: ShortAnnotations.kt
                   INTEGER_CONSTANT
                     PsiElement(INTEGER_LITERAL)('1')
                 PsiElement(RPAR)(')')
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             PsiWhiteSpace(' ')
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -1089,10 +899,9 @@ JetFile: ShortAnnotations.kt
                   INTEGER_CONSTANT
                     PsiElement(INTEGER_LITERAL)('1')
                 PsiElement(RPAR)(')')
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             PsiWhiteSpace(' ')
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -1122,5 +931,68 @@ JetFile: ShortAnnotations.kt
             PsiElement(INTEGER_LITERAL)('1')
         PsiWhiteSpace('\n  ')
         PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n\n  ')
+      WHEN
+        PsiElement(when)('when')
+        PsiWhiteSpace(' ')
+        PsiElement(LPAR)('(')
+        BINARY_EXPRESSION
+          BINARY_EXPRESSION
+            BINARY_EXPRESSION
+              BINARY_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('foo')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(IDENTIFIER)('bar')
+                PARENTHESIZED
+                  PsiElement(LPAR)('(')
+                  INTEGER_CONSTANT
+                    PsiElement(INTEGER_LITERAL)('1')
+                  PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(IDENTIFIER)('buzz')
+              PsiErrorElement:Expecting an element
+                PsiElement(LT)('<')
+            OPERATION_REFERENCE
+              PsiElement(IDENTIFIER)('T')
+            CALL_EXPRESSION
+              PsiErrorElement:Expecting an element
+                PsiElement(GT)('>')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                VALUE_ARGUMENT
+                  INTEGER_CONSTANT
+                    PsiElement(INTEGER_LITERAL)('1')
+                PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
+          OPERATION_REFERENCE
+            PsiElement(IDENTIFIER)('zoo')
+          PsiWhiteSpace(' ')
+          PROPERTY
+            PsiElement(val)('val')
+            PsiWhiteSpace(' ')
+            PsiElement(IDENTIFIER)('a')
+            PsiWhiteSpace(' ')
+            PsiElement(EQ)('=')
+            PsiWhiteSpace(' ')
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+        PsiElement(RPAR)(')')
+        PsiWhiteSpace(' ')
+        PsiElement(LBRACE)('{')
+        PsiWhiteSpace('\n    ')
+        WHEN_ENTRY
+          WHEN_CONDITION_WITH_EXPRESSION
+            INTEGER_CONSTANT
+              PsiElement(INTEGER_LITERAL)('1')
+          PsiWhiteSpace(' ')
+          PsiElement(ARROW)('->')
+          PsiWhiteSpace(' ')
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+        PsiWhiteSpace('\n  ')
+        PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')

compiler/testData/psi/annotation/forParameters.kt

@@ -8,14 +8,14 @@ fun foo() {
 
     for ((@[ann], x) in pair) {}
 
-    for (Volatile x in 1..100) {}
+    for (@Volatile x in 1..100) {}
-    for (Volatile(1) x in 1..100) {}
+    for (@Volatile(1) x in 1..100) {}
-    for (Volatile() (x, Volatile y) in 1..100) {}
+    for (@Volatile() (x, @Volatile y) in 1..100) {}
-    for (Volatile (x, Volatile y) in 1..100) {}
+    for (@Volatile (x, @Volatile y) in 1..100) {}
 
-    for (Volatile var x in 1..100) {}
+    for (@Volatile var x in 1..100) {}
-    for (Volatile val (x, Volatile y) in 1..100) {}
+    for (@Volatile val (x, @Volatile y) in 1..100) {}
 
-    for (private Volatile var x in 1..100) {}
+    for (private @Volatile var x in 1..100) {}
-    for (private Volatile val (x, Volatile y) in 1..100) {}
+    for (private @Volatile val (x, @Volatile y) in 1..100) {}
 }

compiler/testData/psi/annotation/forParameters.txt

@@ -78,19 +78,11 @@ JetFile: forParameters.kt
               PsiElement(AT)('@')
             PsiWhiteSpace(' ')
             PsiElement(in)('in')
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
           PsiWhiteSpace(' ')
-            ANNOTATION_ENTRY
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('z')
-          PsiErrorElement:Expecting a variable name
-            PsiElement(RPAR)(')')
         PsiErrorElement:Expecting 'in'
           <empty list>
+        PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         BODY
           BLOCK
@@ -191,9 +183,8 @@ JetFile: forParameters.kt
         PsiElement(LPAR)('(')
         VALUE_PARAMETER
           MODIFIER_LIST
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -225,9 +216,8 @@ JetFile: forParameters.kt
         PsiElement(LPAR)('(')
         VALUE_PARAMETER
           MODIFIER_LIST
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -265,9 +255,8 @@ JetFile: forParameters.kt
         PsiElement(LPAR)('(')
         MULTI_VARIABLE_DECLARATION
           MODIFIER_LIST
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -284,9 +273,8 @@ JetFile: forParameters.kt
           PsiWhiteSpace(' ')
           MULTI_VARIABLE_DECLARATION_ENTRY
             MODIFIER_LIST
-              PsiErrorElement:Use '@' symbol before annotations
-                <empty list>
               ANNOTATION_ENTRY
+                PsiElement(AT)('@')
                 CONSTRUCTOR_CALLEE
                   TYPE_REFERENCE
                     USER_TYPE
@@ -319,9 +307,8 @@ JetFile: forParameters.kt
         PsiElement(LPAR)('(')
         MULTI_VARIABLE_DECLARATION
           MODIFIER_LIST
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -335,9 +322,8 @@ JetFile: forParameters.kt
           PsiWhiteSpace(' ')
           MULTI_VARIABLE_DECLARATION_ENTRY
             MODIFIER_LIST
-              PsiErrorElement:Use '@' symbol before annotations
-                <empty list>
               ANNOTATION_ENTRY
+                PsiElement(AT)('@')
                 CONSTRUCTOR_CALLEE
                   TYPE_REFERENCE
                     USER_TYPE
@@ -370,9 +356,8 @@ JetFile: forParameters.kt
         PsiElement(LPAR)('(')
         VALUE_PARAMETER
           MODIFIER_LIST
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -406,9 +391,8 @@ JetFile: forParameters.kt
         PsiElement(LPAR)('(')
         MULTI_VARIABLE_DECLARATION
           MODIFIER_LIST
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -424,9 +408,8 @@ JetFile: forParameters.kt
           PsiWhiteSpace(' ')
           MULTI_VARIABLE_DECLARATION_ENTRY
             MODIFIER_LIST
-              PsiErrorElement:Use '@' symbol before annotations
-                <empty list>
               ANNOTATION_ENTRY
+                PsiElement(AT)('@')
                 CONSTRUCTOR_CALLEE
                   TYPE_REFERENCE
                     USER_TYPE
@@ -460,10 +443,9 @@ JetFile: forParameters.kt
         VALUE_PARAMETER
           MODIFIER_LIST
             PsiElement(private)('private')
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             PsiWhiteSpace(' ')
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -498,10 +480,9 @@ JetFile: forParameters.kt
         MULTI_VARIABLE_DECLARATION
           MODIFIER_LIST
             PsiElement(private)('private')
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
             PsiWhiteSpace(' ')
             ANNOTATION_ENTRY
+              PsiElement(AT)('@')
               CONSTRUCTOR_CALLEE
                 TYPE_REFERENCE
                   USER_TYPE
@@ -517,9 +498,8 @@ JetFile: forParameters.kt
           PsiWhiteSpace(' ')
           MULTI_VARIABLE_DECLARATION_ENTRY
             MODIFIER_LIST
-              PsiErrorElement:Use '@' symbol before annotations
-                <empty list>
               ANNOTATION_ENTRY
+                PsiElement(AT)('@')
                 CONSTRUCTOR_CALLEE
                   TYPE_REFERENCE
                     USER_TYPE

compiler/testData/psi/annotation/noParameterYet.kt

@@ -0,0 +1 @@
+fun foo(@Deprecated)

compiler/testData/psi/annotation/noParameterYet.txt

@@ -0,0 +1,23 @@
+JetFile: noParameterYet.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        MODIFIER_LIST
+          ANNOTATION_ENTRY
+            PsiElement(AT)('@')
+            CONSTRUCTOR_CALLEE
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Deprecated')
+        PsiErrorElement:Parameter name expected
+          <empty list>
+      PsiElement(RPAR)(')')

compiler/testData/psi/annotation/targeted/onParam/targetExpected.txt

@@ -137,12 +137,19 @@ JetFile: targetExpected.kt
         PsiElement(LPAR)('(')
         VALUE_PARAMETER
           MODIFIER_LIST
-            PsiErrorElement:Expected annotation identifier after ':'
+            ANNOTATION_ENTRY
               PsiElement(AT)('@')
+              PsiErrorElement:Expected annotation target before ':'
                 PsiElement(IDENTIFIER)('fiield')
               PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('a')
+          PsiErrorElement:Parameter name expected
+            <empty list>
           PsiElement(COLON)(':')
           PsiWhiteSpace(' ')
           TYPE_REFERENCE
@@ -171,17 +178,8 @@ JetFile: targetExpected.kt
               PsiErrorElement:Expecting a list of annotations
                 <empty list>
               PsiElement(RBRACKET)(']')
-            PsiErrorElement:Use '@' symbol before annotations
-              <empty list>
           PsiWhiteSpace(' ')
-            ANNOTATION_ENTRY
-              CONSTRUCTOR_CALLEE
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('a')
-          PsiErrorElement:Parameter name expected
-            <empty list>
           PsiElement(COLON)(':')
           PsiWhiteSpace(' ')
           TYPE_REFERENCE

compiler/testData/psi/functionReceivers/FunctionsWithFunctionReceivers.txt

@@ -288,20 +288,14 @@ JetFile: FunctionsWithFunctionReceivers.kt
     PsiElement(RPAR)(')')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(DOT)('.')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiWhiteSpace('\n')
+  FUN
     PsiElement(fun)('fun')
     PsiWhiteSpace(' ')
     TYPE_PARAMETER_LIST
@@ -434,21 +428,14 @@ JetFile: FunctionsWithFunctionReceivers.kt
       PsiElement(LPAR)('(')
       PsiElement(RPAR)(')')
   PsiWhiteSpace('\n')
-  CLASS
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('a')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(IDENTIFIER)('b')
   PsiWhiteSpace(' ')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('C')

compiler/testData/psi/functionReceivers/FunctionsWithFunctionReceiversRecovery.txt

@@ -311,62 +311,39 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('a')
       PsiElement(RBRACKET)(']')
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
   PsiWhiteSpace(' ')
-    ANNOTATION_ENTRY
+  PsiErrorElement:Expecting a top level declaration
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
-            TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-              TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(DOT)('.')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-  MODIFIER_LIST
+  PsiErrorElement:Expecting a top level declaration
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('A')
-            TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-              TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('B')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(DOT)('.')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiWhiteSpace('\n\n')
+  FUN
     PsiElement(fun)('fun')
     PsiWhiteSpace(' ')
     TYPE_REFERENCE
@@ -441,14 +418,7 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
       <empty list>
   PsiErrorElement:Expecting a top level declaration
     PsiElement(LBRACKET)('[')
-  MODIFIER_LIST
+  PsiErrorElement:Expecting a top level declaration
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('a')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RBRACKET)(']')
@@ -457,22 +427,13 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
     PsiElement(LPAR)('(')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
-  MODIFIER_LIST
+  PsiErrorElement:Expecting a top level declaration
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('A')
-            TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-              TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('B')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
@@ -482,20 +443,14 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
     PsiElement(RPAR)(')')
   PsiErrorElement:Expecting a top level declaration
     PsiElement(DOT)('.')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('foo')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
   PsiWhiteSpace('\n\n')
+  FUN
     PsiElement(fun)('fun')
     PsiWhiteSpace(' ')
     TYPE_REFERENCE
@@ -553,29 +508,18 @@ JetFile: FunctionsWithFunctionReceiversRecovery.kt
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
-  CLASS
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('c')
-                TYPE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LT)('<')
-                  TYPE_PROJECTION
+  PsiErrorElement:Expecting a top level declaration
-                    TYPE_REFERENCE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('t')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(GT)('>')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(DOT)('.')
-              PsiErrorElement:Expecting type name
-                <empty list>
   PsiWhiteSpace('\n\n')
+  CLASS
     PsiComment(EOL_COMMENT)('//-----------')
     PsiWhiteSpace('\n')
     PsiElement(class)('class')

compiler/testData/psi/functionReceivers/PropertiesWithFunctionReceivers.txt

@@ -447,22 +447,16 @@ JetFile: PropertiesWithFunctionReceivers.kt
         PsiElement(LBRACE)('{')
         PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n   ')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('dfget')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  FUN
     PsiErrorElement:Expecting a top level declaration
       <empty list>
-    PsiWhiteSpace(' ')
     BLOCK
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
@@ -526,22 +520,16 @@ JetFile: PropertiesWithFunctionReceivers.kt
         PsiElement(LBRACE)('{')
         PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n   ')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('set')
-        VALUE_ARGUMENT_LIST
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
     PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  FUN
     PsiErrorElement:Expecting a top level declaration
       <empty list>
-    PsiWhiteSpace(' ')
     BLOCK
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')

compiler/testData/psi/greatSyntacticShift/functionTypes.txt

@@ -16,19 +16,12 @@ JetFile: functionTypes.kt
   PsiErrorElement:Expecting a top level declaration
     PsiElement(package)('package')
   PsiWhiteSpace(' ')
-  FUN
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('n')
+  PsiWhiteSpace(' ')
+  FUN
     PsiErrorElement:Expecting a top level declaration
       <empty list>
-    PsiWhiteSpace(' ')
     BLOCK
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n  ')

compiler/testData/psi/packages/PackageLeadingDotDoubleID.txt

@@ -9,14 +9,5 @@ JetFile: PackageLeadingDotDoubleID.kt
   IMPORT_LIST
     <empty list>
   PsiWhiteSpace(' ')
-  MODIFIER_LIST
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
   PsiErrorElement:Expecting a top level declaration
-    <empty list>
+    PsiElement(IDENTIFIER)('b')

compiler/testData/psi/packages/PackageLongNameDoubleID.txt

@@ -7,14 +7,5 @@ JetFile: PackageLongNameDoubleID.kt
   IMPORT_LIST
     <empty list>
   PsiWhiteSpace(' ')
-  MODIFIER_LIST
-    PsiErrorElement:Use '@' symbol before annotations
-      <empty list>
-    ANNOTATION_ENTRY
-      CONSTRUCTOR_CALLEE
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
   PsiErrorElement:Expecting a top level declaration
-    <empty list>
+    PsiElement(IDENTIFIER)('b')

compiler/testData/psi/platformTypesRecovery/FunctionsNotPlatform.txt

@@ -97,11 +97,10 @@ JetFile: FunctionsNotPlatform.kt
                     VALUE_PARAMETER_LIST
                       PsiElement(LPAR)('(')
                       VALUE_PARAMETER
-                        MODIFIER_LIST
-                          PsiElement(out)('out')
                         TYPE_REFERENCE
-                          PsiErrorElement:Type expected
+                          USER_TYPE
-                            <empty list>
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('out')
                       PsiElement(RPAR)(')')
                     PsiWhiteSpace(' ')
                     PsiElement(ARROW)('->')
@@ -145,11 +144,10 @@ JetFile: FunctionsNotPlatform.kt
                     VALUE_PARAMETER_LIST
                       PsiElement(LPAR)('(')
                       VALUE_PARAMETER
-                        MODIFIER_LIST
-                          PsiElement(out)('out')
                         TYPE_REFERENCE
-                          PsiErrorElement:Type expected
+                          USER_TYPE
-                            <empty list>
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('out')
                       PsiElement(RPAR)(')')
                     PsiWhiteSpace(' ')
                     PsiElement(ARROW)('->')

compiler/testData/psi/primaryConstructor/recovery.txt

@@ -82,17 +82,10 @@ JetFile: recovery.kt
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('A2')
   PsiWhiteSpace(' ')
-  CLASS
+  PsiErrorElement:Expecting a top level declaration
-    MODIFIER_LIST
-      PsiErrorElement:Use '@' symbol before annotations
-        <empty list>
-      ANNOTATION_ENTRY
-        CONSTRUCTOR_CALLEE
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
     PsiElement(IDENTIFIER)('Ann')
   PsiWhiteSpace('\n\n')
+  CLASS
     PsiElement(class)('class')
     PsiWhiteSpace(' ')
     PsiElement(IDENTIFIER)('A3')

compiler/tests/org/jetbrains/kotlin/parsing/JetParsingTestGenerated.java

@@ -819,6 +819,12 @@ public class JetParsingTestGenerated extends AbstractJetParsingTest {
                 doParsingTest(fileName);
             }
 
+            @TestMetadata("noParameterYet.kt")
+            public void testNoParameterYet() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/noParameterYet.kt");
+                doParsingTest(fileName);
+            }
+
             @TestMetadata("oldAnnotationsRecovery.kt")
             public void testOldAnnotationsRecovery() throws Exception {
                 String fileName = JetTestUtils.navigationMetadata("compiler/testData/psi/annotation/oldAnnotationsRecovery.kt");