Stop parsing lambdas with deprecated syntax

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

@@ -1044,7 +1044,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
      * functionLiteral  // one can use "it" as a parameter name
      *   : "{" expressions "}"
      *   : "{" (modifiers SimpleName){","} "->" statements "}"
-     *   : "{" (type ".")? "(" (modifiers SimpleName (":" type)?){","} ")" (":" type)? "->" expressions "}"
      *   ;
      */
     private void parseFunctionLiteral() {
@@ -1069,25 +1068,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
             advance(); // ARROW
             paramsFound = true;
         }
-        else if (at(LPAR)) {
-            // Look for ARROW after matching RPAR
-            //   {(a, b) -> ...}
-
-            {
-                PsiBuilder.Marker rollbackMarker = mark();
-                boolean preferParamsToExpressions = parseFunctionLiteralParametersAndType();
-
-                paramsFound = preferParamsToExpressions ?
-                              rollbackOrDrop(rollbackMarker, ARROW, "An -> is expected", RBRACE) :
-                              rollbackOrDropAt(rollbackMarker, ARROW);
-            }
-
-            if (!paramsFound) {
-                // If not found, try a typeRef DOT and then LPAR .. RPAR ARROW
-                //   {((A) -> B).(x) -> ... }
-                paramsFound = parseFunctionTypeDotParametersAndType();
-            }
-        }
         else {
             if (at(IDENTIFIER) || at(COLON)) {
                 // Try to parse a simple name list followed by an ARROW
@@ -1101,11 +1081,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
                               rollbackOrDrop(rollbackMarker, ARROW, "An -> is expected", RBRACE) :
                               rollbackOrDropAt(rollbackMarker, ARROW);
             }
-            if (!paramsFound && atSet(JetParsing.TYPE_REF_FIRST)) {
-                // Try to parse a type DOT valueParameterList ARROW
-                //   {A.(b) -> ...}
-                paramsFound = parseFunctionTypeDotParametersAndType();
-            }
         }
 
         if (!paramsFound) {
@@ -1200,110 +1175,6 @@ public class JetExpressionParsing extends AbstractJetParsing {
         parameterList.done(VALUE_PARAMETER_LIST);
     }
 
-    private boolean parseFunctionTypeDotParametersAndType() {
-        PsiBuilder.Marker rollbackMarker = mark();
-
-        // True when it's confirmed that body of literal can't be simple expressions and we prefer to parse
-        // it to function params if possible.
-        boolean preferParamsToExpressions = false;
-
-        // Last dot before ARROW and RPAR, but also stop at top-level keywords and '{', '}'
-        int lastDot = matchTokenStreamPredicate(new LastBefore(
-                new At(DOT),
-                new AtSet(TokenSet.orSet(
-                        TokenSet.create(ARROW, RPAR),
-                        TokenSet.orSet(
-                                TokenSet.create(LBRACE, RBRACE),
-                                TokenSet.andNot(
-                                        KEYWORDS,
-                                        TokenSet.create(CAPITALIZED_THIS_KEYWORD)
-                                )
-                        )
-                ))
-        ));
-
-        if (lastDot >= 0) {
-            createTruncatedBuilder(lastDot).parseTypeRef();
-            if (at(DOT)) {
-                advance(); // DOT
-                preferParamsToExpressions = parseFunctionLiteralParametersAndType();
-            }
-        }
-
-        return preferParamsToExpressions ?
-               rollbackOrDrop(rollbackMarker, ARROW, "An -> is expected", RBRACE) :
-               rollbackOrDropAt(rollbackMarker, ARROW);
-    }
-
-    private boolean parseFunctionLiteralParametersAndType() {
-        boolean hasCommaInParametersList = parseFunctionLiteralParameterList();
-        parseOptionalFunctionLiteralType();
-        return hasCommaInParametersList;
-    }
-
-    /*
-     * (":" type)?
-     */
-    private void parseOptionalFunctionLiteralType() {
-        if (at(COLON)) {
-            advance(); // COLON
-            if (at(ARROW)) {
-                error("Expecting a type");
-            }
-            else {
-                myJetParsing.parseTypeRef();
-            }
-        }
-    }
-
-    /**
-     * "(" (modifiers SimpleName (":" type)?){","} ")"
-     *
-     * @return true if at least one comma was found
-     */
-    private boolean parseFunctionLiteralParameterList() {
-        PsiBuilder.Marker list = mark();
-        expect(LPAR, "Expecting a parameter list in parentheses (...)", TokenSet.create(ARROW, COLON));
-
-        boolean hasComma = false;
-
-        myBuilder.disableNewlines();
-
-        if (!at(RPAR)) {
-            while (true) {
-                if (at(COMMA)) errorAndAdvance("Expecting a parameter declaration");
-
-                PsiBuilder.Marker parameter = mark();
-                int parameterNamePos = matchTokenStreamPredicate(new LastBefore(new At(IDENTIFIER), new AtSet(COMMA, RPAR, COLON, ARROW, RBRACE, LBRACE)));
-                createTruncatedBuilder(parameterNamePos).parseModifierList(ONLY_ESCAPED_REGULAR_ANNOTATIONS);
-
-                expect(IDENTIFIER, "Expecting parameter declaration");
-
-                if (at(COLON)) {
-                    advance(); // COLON
-                    myJetParsing.parseTypeRef();
-                }
-                parameter.done(VALUE_PARAMETER);
-                if (!at(COMMA)) break;
-                advance(); // COMMA
-
-                hasComma = true;
-
-                if (at(RPAR)) {
-                    error("Expecting a parameter declaration");
-                    break;
-                }
-            }
-        }
-
-        myBuilder.restoreNewlinesState();
-
-        expect(RPAR, "Expecting ')'", TokenSet.create(ARROW, COLON));
-        list.done(VALUE_PARAMETER_LIST);
-
-        return hasComma;
-    }
-
     /*
      * expressions
      *   : SEMI* statement{SEMI+} SEMI*

compiler/testData/psi/CallsInWhen.kt

@@ -7,7 +7,7 @@ fun foo() {
     a.foo<T>(a, d) -> a
     a.{bar} -> a
     a.{!bar} -> a
-    a.{() -> !bar} -> a
+    a.{ -> !bar} -> a
     else -> a
   }
 }

compiler/testData/psi/CallsInWhen.txt

@@ -192,10 +192,9 @@ JetFile: CallsInWhen.kt
               FUNCTION_LITERAL_EXPRESSION
                 FUNCTION_LITERAL
                   PsiElement(LBRACE)('{')
-                  VALUE_PARAMETER_LIST
-                    PsiElement(LPAR)('(')
-                    PsiElement(RPAR)(')')
                   PsiWhiteSpace(' ')
+                  VALUE_PARAMETER_LIST
+                    <empty list>
                   PsiElement(ARROW)('->')
                   PsiWhiteSpace(' ')
                   BLOCK

compiler/testData/psi/FunctionLiterals.txt

@@ -46,396 +46,416 @@ JetFile: FunctionLiterals.kt
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
+          BLOCK
-            PsiElement(LPAR)('(')
+            PARENTHESIZED
-            VALUE_PARAMETER
+              PsiElement(LPAR)('(')
-              PsiElement(IDENTIFIER)('a')
+              BINARY_WITH_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
               PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            BINARY_WITH_TYPE
+              PARENTHESIZED
+                PsiElement(LPAR)('(')
+                BINARY_WITH_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(COLON)(':')
+                  PsiWhiteSpace(' ')
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('A')
+                PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
+                    PsiElement(IDENTIFIER)('T')
-            PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-          PsiElement(ARROW)('->')
+              PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
+              PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
+          BLOCK
-            PsiElement(LPAR)('(')
+            BINARY_WITH_TYPE
-            VALUE_PARAMETER
+              PARENTHESIZED
-              PsiElement(IDENTIFIER)('a')
+                PsiElement(LPAR)('(')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
+              OPERATION_REFERENCE
+                PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
+                    PsiElement(IDENTIFIER)('T')
-            PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-          PsiElement(COLON)(':')
+              PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
+              PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n    ')
-      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
-              PsiElement(IDENTIFIER)('a')
+              PsiElement(LPAR)('(')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n    ')
-      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n    ')
-      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
+                PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
+              PsiErrorElement:Expecting ')'
-          PsiElement(ARROW)('->')
+                <empty list>
-          PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-          BLOCK
+              PsiElement(COMMA)(',')
-            REFERENCE_EXPRESSION
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
+          BLOCK
-            PsiElement(LPAR)('(')
+            PARENTHESIZED
-            VALUE_PARAMETER
+              PsiElement(LPAR)('(')
-              PsiElement(IDENTIFIER)('a')
+              BINARY_WITH_TYPE
-            PsiElement(COMMA)(',')
+                REFERENCE_EXPRESSION
-            PsiWhiteSpace(' ')
+                  PsiElement(IDENTIFIER)('a')
-            VALUE_PARAMETER
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
               PsiWhiteSpace(' ')
               PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
-              TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('B')
-                USER_TYPE
+              PsiElement(RPAR)(')')
-                  REFERENCE_EXPRESSION
+              PsiWhiteSpace(' ')
-                    PsiElement(IDENTIFIER)('B')
+              PsiElement(ARROW)('->')
-            PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
-          PsiElement(COLON)(':')
+          PsiElement(RBRACE)('}')
-          PsiWhiteSpace(' ')
+      PsiWhiteSpace('\n    ')
-          TYPE_REFERENCE
+      FUNCTION_LITERAL_EXPRESSION
-            USER_TYPE
+        FUNCTION_LITERAL
-              REFERENCE_EXPRESSION
+          PsiElement(LBRACE)('{')
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              BINARY_WITH_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('T')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('B')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('T')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              PsiErrorElement:Expecting an expression
+                <empty list>
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              PsiErrorElement:Expecting an expression
+                <empty list>
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            BINARY_WITH_TYPE
+              PARENTHESIZED
+                PsiElement(LPAR)('(')
+                PsiErrorElement:Expecting an expression
+                  <empty list>
+                PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            BINARY_WITH_TYPE
+              PARENTHESIZED
+                PsiElement(LPAR)('(')
+                PsiErrorElement:Expecting an expression
+                  <empty list>
+                PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
+          BLOCK
-            USER_TYPE
+            DOT_QUALIFIED_EXPRESSION
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
+              PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
+              PARENTHESIZED
-            PsiElement(LPAR)('(')
+                PsiElement(LPAR)('(')
-            VALUE_PARAMETER
+                REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+                  PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
+                PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
+            PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-          PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
-          BLOCK
+              PsiWhiteSpace(' ')
-            REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
+          BLOCK
-            USER_TYPE
+            DOT_QUALIFIED_EXPRESSION
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
+              PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
+              PARENTHESIZED
-            PsiElement(LPAR)('(')
+                PsiElement(LPAR)('(')
-            VALUE_PARAMETER
+                BINARY_WITH_TYPE
-              PsiElement(IDENTIFIER)('a')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiWhiteSpace(' ')
+                  OPERATION_REFERENCE
+                    PsiElement(COLON)(':')
+                  PsiWhiteSpace(' ')
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('A')
+                PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
               PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            BINARY_WITH_TYPE
+              DOT_QUALIFIED_EXPRESSION
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+                PsiElement(DOT)('.')
+                PARENTHESIZED
+                  PsiElement(LPAR)('(')
+                  BINARY_WITH_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(COLON)(':')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('A')
+                  PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
+                    PsiElement(IDENTIFIER)('T')
-            PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-          PsiElement(ARROW)('->')
+              PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
+              PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
+          BLOCK
-            USER_TYPE
+            BINARY_WITH_TYPE
-              REFERENCE_EXPRESSION
+              DOT_QUALIFIED_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
+                REFERENCE_EXPRESSION
-          PsiElement(DOT)('.')
+                  PsiElement(IDENTIFIER)('T')
-          VALUE_PARAMETER_LIST
+                PsiElement(DOT)('.')
-            PsiElement(LPAR)('(')
+                PARENTHESIZED
-            VALUE_PARAMETER
+                  PsiElement(LPAR)('(')
-              PsiElement(IDENTIFIER)('a')
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('a')
+                  PsiElement(RPAR)(')')
               PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
+              OPERATION_REFERENCE
+                PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
+                    PsiElement(IDENTIFIER)('T')
-            PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-          PsiElement(COLON)(':')
+              PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
+              PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n    ')
-      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
@@ -501,21 +521,25 @@ JetFile: FunctionLiterals.kt
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
+          BLOCK
-            PsiElement(LPAR)('(')
+            PARENTHESIZED
-            FUNCTION_TYPE
+              PsiElement(LPAR)('(')
-              VALUE_PARAMETER_LIST
+              PARENTHESIZED
                 PsiElement(LPAR)('(')
-                VALUE_PARAMETER
+                BINARY_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
+                  BINARY_WITH_TYPE
-                  PsiElement(COLON)(':')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                    OPERATION_REFERENCE
+                      PsiElement(COLON)(':')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Int')
                   PsiWhiteSpace(' ')
-                  TYPE_REFERENCE
+                  OPERATION_REFERENCE
-                    USER_TYPE
+                    PsiElement(EQ)('=')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Int')
-                  PsiWhiteSpace(' ')
-                  PsiElement(EQ)('=')
                   PsiWhiteSpace(' ')
                   OBJECT_LITERAL
                     OBJECT_DECLARATION
@@ -538,38 +562,28 @@ JetFile: FunctionLiterals.kt
                         PsiWhiteSpace(' ')
                         PsiElement(RBRACE)('}')
                 PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
               PsiElement(ARROW)('->')
               PsiWhiteSpace(' ')
-              TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('Int')
-                USER_TYPE
+              PsiElement(RPAR)(')')
-                  REFERENCE_EXPRESSION
+              PsiElement(DOT)('.')
-                    PsiElement(IDENTIFIER)('Int')
+              PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
               PsiElement(IDENTIFIER)('x')
               PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
-              TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('Int')
-                USER_TYPE
+              PsiElement(RPAR)(')')
-                  REFERENCE_EXPRESSION
+              PsiWhiteSpace(' ')
-                    PsiElement(IDENTIFIER)('Int')
+              PsiElement(COLON)(':')
-            PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('String')
-          PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
-          TYPE_REFERENCE
+              PsiWhiteSpace(' ')
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('String')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            STRING_TEMPLATE
               PsiElement(OPEN_QUOTE)('"')
               PsiElement(CLOSING_QUOTE)('"')
           PsiWhiteSpace(' ')
@@ -579,95 +593,91 @@ JetFile: FunctionLiterals.kt
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
           PsiWhiteSpace(' ')
-          TYPE_REFERENCE
+          BLOCK
-            USER_TYPE
+            DOT_QUALIFIED_EXPRESSION
-              USER_TYPE
+              DOT_QUALIFIED_EXPRESSION
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('A')
+                PsiElement(DOT)('.')
+                CALL_EXPRESSION
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('B')
+                  TYPE_ARGUMENT_LIST
+                    PsiElement(LT)('<')
+                    TYPE_PROJECTION
+                      TYPE_REFERENCE
+                        USER_TYPE
+                          REFERENCE_EXPRESSION
+                            PsiElement(IDENTIFIER)('String')
+                    PsiElement(GT)('>')
               PsiElement(DOT)('.')
-              REFERENCE_EXPRESSION
+              PARENTHESIZED
-                PsiElement(IDENTIFIER)('B')
+                PsiElement(LPAR)('(')
-              TYPE_ARGUMENT_LIST
+                BINARY_WITH_TYPE
-                PsiElement(LT)('<')
+                  REFERENCE_EXPRESSION
-                TYPE_PROJECTION
+                    PsiElement(IDENTIFIER)('x')
+                  OPERATION_REFERENCE
+                    PsiElement(COLON)(':')
+                  PsiWhiteSpace(' ')
                   TYPE_REFERENCE
                     USER_TYPE
                       REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('String')
+                        PsiElement(IDENTIFIER)('Int')
-                PsiElement(GT)('>')
+                PsiElement(RPAR)(')')
-          PsiElement(DOT)('.')
+            PsiWhiteSpace(' ')
-          VALUE_PARAMETER_LIST
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-            PsiElement(LPAR)('(')
+              PsiElement(ARROW)('->')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('x')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('Int')
-            PsiElement(RPAR)(')')
           PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            <empty list>
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
+          BLOCK
-            PsiElement(LPAR)('(')
+            PARENTHESIZED
-            FUNCTION_TYPE
+              PsiElement(LPAR)('(')
-              VALUE_PARAMETER_LIST
+              PARENTHESIZED
                 PsiElement(LPAR)('(')
-                VALUE_PARAMETER
+                BINARY_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
+                  BINARY_WITH_TYPE
-                  PsiElement(COLON)(':')
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                    OPERATION_REFERENCE
+                      PsiElement(COLON)(':')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Boolean')
                   PsiWhiteSpace(' ')
-                  TYPE_REFERENCE
+                  OPERATION_REFERENCE
-                    USER_TYPE
+                    PsiElement(EQ)('=')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Boolean')
-                  PsiWhiteSpace(' ')
-                  PsiElement(EQ)('=')
                   PsiWhiteSpace(' ')
                   BOOLEAN_CONSTANT
                     PsiElement(true)('true')
                 PsiElement(RPAR)(')')
-              PsiWhiteSpace(' ')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
               PsiElement(ARROW)('->')
               PsiWhiteSpace(' ')
-              TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('Int')
-                USER_TYPE
+              PsiElement(RPAR)(')')
-                  REFERENCE_EXPRESSION
+              PsiElement(DOT)('.')
-                    PsiElement(IDENTIFIER)('Int')
+              PsiElement(LPAR)('(')
-            PsiElement(RPAR)(')')
-          PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
               PsiElement(IDENTIFIER)('x')
               PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
-              TYPE_REFERENCE
+              PsiElement(IDENTIFIER)('Any')
-                USER_TYPE
+              PsiElement(RPAR)(')')
-                  REFERENCE_EXPRESSION
+              PsiWhiteSpace(' ')
-                    PsiElement(IDENTIFIER)('Any')
+              PsiElement(COLON)(':')
-            PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('Unit')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
           PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('Unit')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            <empty list>
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
       FUNCTION_LITERAL_EXPRESSION

compiler/testData/psi/FunctionLiterals_ERR.txt

@@ -30,187 +30,193 @@ JetFile: FunctionLiterals_ERR.kt
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiErrorElement:Expecting ')'
-              <empty list>
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                PsiErrorElement:Type expected
-                  <empty list>
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              BINARY_WITH_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  PsiErrorElement:Type expected
+                    <empty list>
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
+          BLOCK
-            PsiElement(LPAR)('(')
+            BINARY_EXPRESSION
-            VALUE_PARAMETER
+              BINARY_WITH_TYPE
-              PsiElement(IDENTIFIER)('a')
+                PARENTHESIZED
+                  PsiElement(LPAR)('(')
+                  BINARY_WITH_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('a')
+                    PsiWhiteSpace(' ')
+                    OPERATION_REFERENCE
+                      PsiElement(COLON)(':')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('A')
+                  PsiElement(RPAR)(')')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  PsiErrorElement:Type expected
+                    PsiElement(ARROW)('->')
               PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
+              OPERATION_REFERENCE
+                PsiElement(IDENTIFIER)('a')
+              PsiErrorElement:Expecting an element
+                <empty list>
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            BINARY_WITH_TYPE
+              PARENTHESIZED
+                PsiElement(LPAR)('(')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              OPERATION_REFERENCE
+                PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
+                    PsiElement(IDENTIFIER)('T')
-            PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(ARROW)('->')
           PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiErrorElement:Expecting a type
-            <empty list>
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n    ')
-      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            <empty list>
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
-            PsiErrorElement:Expecting a parameter declaration
-              <empty list>
-            PsiWhiteSpace(' ')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
-              PsiElement(IDENTIFIER)('a')
+              PsiElement(LPAR)('(')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n    ')
-      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            PsiErrorElement:Expecting a parameter declaration
-              PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('B')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(ARROW)('->')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
-          PsiElement(RBRACE)('}')
-      PsiWhiteSpace('\n    ')
-      FUNCTION_LITERAL_EXPRESSION
-        FUNCTION_LITERAL
-          PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiWhiteSpace(' ')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('A')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            PsiErrorElement:Expecting a parameter declaration
-              PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiErrorElement:Expecting parameter declaration
-                <empty list>
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(RPAR)(')')
-          PsiWhiteSpace(' ')
-          PsiElement(COLON)(':')
-          PsiWhiteSpace(' ')
-          TYPE_REFERENCE
-            USER_TYPE
               REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
+                PsiElement(IDENTIFIER)('a')
-          PsiWhiteSpace(' ')
+              PsiErrorElement:Expecting ')'
-          PsiElement(ARROW)('->')
+                <empty list>
-          PsiWhiteSpace(' ')
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
           BLOCK
-            REFERENCE_EXPRESSION
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              BINARY_WITH_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('B')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+          PsiElement(RBRACE)('}')
+      PsiWhiteSpace('\n    ')
+      FUNCTION_LITERAL_EXPRESSION
+        FUNCTION_LITERAL
+          PsiElement(LBRACE)('{')
+          BLOCK
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              BINARY_WITH_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                PsiWhiteSpace(' ')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('A')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('a')
+              PsiElement(RPAR)(')')
+              PsiWhiteSpace(' ')
+              PsiElement(COLON)(':')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('T')
+              PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('a')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
@@ -401,99 +407,91 @@ JetFile: FunctionLiterals_ERR.kt
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
+          BLOCK
-            USER_TYPE
+            BINARY_WITH_TYPE
-              REFERENCE_EXPRESSION
+              DOT_QUALIFIED_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
+                REFERENCE_EXPRESSION
-          PsiElement(DOT)('.')
+                  PsiElement(IDENTIFIER)('T')
-          VALUE_PARAMETER_LIST
+                PsiElement(DOT)('.')
-            PsiErrorElement:Expecting a parameter list in parentheses (...)
+                REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+                  PsiElement(IDENTIFIER)('a')
-            PsiWhiteSpace(' ')
+              PsiWhiteSpace(' ')
-            VALUE_PARAMETER
+              OPERATION_REFERENCE
-              PsiErrorElement:Expecting parameter declaration
+                PsiElement(COLON)(':')
-                <empty list>
-              PsiElement(COLON)(':')
               PsiWhiteSpace(' ')
               TYPE_REFERENCE
                 USER_TYPE
                   REFERENCE_EXPRESSION
                     PsiElement(IDENTIFIER)('b')
-            PsiErrorElement:Expecting ')'
+            PsiWhiteSpace(' ')
-              <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-          PsiWhiteSpace(' ')
+              PsiElement(ARROW)('->')
-          PsiElement(ARROW)('->')
+              PsiWhiteSpace(' ')
-          PsiWhiteSpace(' ')
-          BLOCK
-            REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('f')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
-            PsiWhiteSpace(' ')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('b')
-            PsiElement(RPAR)(')')
-          PsiErrorElement:An -> is expected
-            <empty list>
-          PsiWhiteSpace(' ')
           BLOCK
-            <empty list>
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(IDENTIFIER)('b')
+              PsiElement(RPAR)(')')
+          PsiWhiteSpace(' ')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          TYPE_REFERENCE
+          BLOCK
-            USER_TYPE
+            DOT_QUALIFIED_EXPRESSION
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('T')
-          PsiElement(DOT)('.')
+              PsiElement(DOT)('.')
-          VALUE_PARAMETER_LIST
+              PARENTHESIZED
-            PsiElement(LPAR)('(')
+                PsiElement(LPAR)('(')
-            VALUE_PARAMETER
+                REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
+                  PsiElement(IDENTIFIER)('a')
-            PsiElement(COMMA)(',')
+                PsiErrorElement:Expecting ')'
-            PsiWhiteSpace(' ')
+                  <empty list>
-            VALUE_PARAMETER
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
               PsiElement(IDENTIFIER)('b')
-            PsiElement(RPAR)(')')
+              PsiElement(RPAR)(')')
-          PsiErrorElement:An -> is expected
-            <empty list>
           PsiWhiteSpace(' ')
-          BLOCK
-            <empty list>
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION
         FUNCTION_LITERAL
           PsiElement(LBRACE)('{')
-          VALUE_PARAMETER_LIST
-            PsiElement(LPAR)('(')
-            VALUE_PARAMETER
-              PsiElement(IDENTIFIER)('a')
-              PsiElement(COLON)(':')
-              PsiWhiteSpace(' ')
-              TYPE_REFERENCE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('Int')
-            PsiElement(COMMA)(',')
-            PsiErrorElement:Expecting a parameter declaration
-              <empty list>
-            PsiWhiteSpace(' ')
-            PsiElement(RPAR)(')')
-          PsiErrorElement:An -> is expected
-            <empty list>
           BLOCK
-            <empty list>
+            PARENTHESIZED
+              PsiElement(LPAR)('(')
+              BINARY_WITH_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('a')
+                OPERATION_REFERENCE
+                  PsiElement(COLON)(':')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Int')
+              PsiErrorElement:Expecting ')'
+                <empty list>
+            PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+              PsiElement(COMMA)(',')
+              PsiWhiteSpace(' ')
+              PsiElement(RPAR)(')')
           PsiElement(RBRACE)('}')
       PsiWhiteSpace('\n    ')
       FUNCTION_LITERAL_EXPRESSION

compiler/testData/psi/examples/FunctionsAndTypes.kt

@@ -22,11 +22,9 @@ typealias Function1<in T, out R> =  (input : T) -> R
 //type Function1<in T, out R> = {(input : T) => R}
 
 
-val f1 = {(t : T) : X -> something(t)}
 fun f1(t : T) : X = something(t)
 
-val f1 = {(t : T) -> something(t)}
+val f1 = {t : T -> something(t)}
-val f1 = {(T) : X -> something(it)}
 val f1 = {t -> something(t)}
 val f1 = {something(it)}
 

compiler/testData/psi/examples/FunctionsAndTypes.txt

@@ -407,50 +407,6 @@ JetFile: FunctionsAndTypes.kt
   PsiWhiteSpace('\n')
   PsiComment(EOL_COMMENT)('//type Function1<in T, out R> = {(input : T) => R}')
   PsiWhiteSpace('\n\n\n')
-  PROPERTY
-    PsiElement(val)('val')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('f1')
-    PsiWhiteSpace(' ')
-    PsiElement(EQ)('=')
-    PsiWhiteSpace(' ')
-    FUNCTION_LITERAL_EXPRESSION
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('t')
-            PsiWhiteSpace(' ')
-            PsiElement(COLON)(':')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('X')
-        PsiWhiteSpace(' ')
-        PsiElement(ARROW)('->')
-        PsiWhiteSpace(' ')
-        BLOCK
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('something')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('t')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
-  PsiWhiteSpace('\n')
   FUN
     PsiElement(fun)('fun')
     PsiWhiteSpace(' ')
@@ -498,7 +454,6 @@ JetFile: FunctionsAndTypes.kt
       FUNCTION_LITERAL
         PsiElement(LBRACE)('{')
         VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
           VALUE_PARAMETER
             PsiElement(IDENTIFIER)('t')
             PsiWhiteSpace(' ')
@@ -508,7 +463,6 @@ JetFile: FunctionsAndTypes.kt
               USER_TYPE
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('T')
-          PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         PsiElement(ARROW)('->')
         PsiWhiteSpace(' ')
@@ -524,43 +478,6 @@ JetFile: FunctionsAndTypes.kt
               PsiElement(RPAR)(')')
         PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n')
-  PROPERTY
-    PsiElement(val)('val')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('f1')
-    PsiWhiteSpace(' ')
-    PsiElement(EQ)('=')
-    PsiWhiteSpace(' ')
-    FUNCTION_LITERAL_EXPRESSION
-      FUNCTION_LITERAL
-        PsiElement(LBRACE)('{')
-        VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
-          VALUE_PARAMETER
-            PsiElement(IDENTIFIER)('T')
-          PsiElement(RPAR)(')')
-        PsiWhiteSpace(' ')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('X')
-        PsiWhiteSpace(' ')
-        PsiElement(ARROW)('->')
-        PsiWhiteSpace(' ')
-        BLOCK
-          CALL_EXPRESSION
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('something')
-            VALUE_ARGUMENT_LIST
-              PsiElement(LPAR)('(')
-              VALUE_ARGUMENT
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('it')
-              PsiElement(RPAR)(')')
-        PsiElement(RBRACE)('}')
-  PsiWhiteSpace('\n')
   PROPERTY
     PsiElement(val)('val')
     PsiWhiteSpace(' ')

compiler/testData/psi/examples/LINQ.kt

@@ -1,3 +1,3 @@
 fun foo() {
-    l filter {it.x} map {it.foo} aggregate {(a, b) -> a + b}
+    l filter {it.x} map {it.foo} aggregate {a, b -> a + b}
 }

compiler/testData/psi/examples/LINQ.txt

@@ -57,14 +57,12 @@ JetFile: LINQ.kt
           FUNCTION_LITERAL
             PsiElement(LBRACE)('{')
             VALUE_PARAMETER_LIST
-              PsiElement(LPAR)('(')
               VALUE_PARAMETER
                 PsiElement(IDENTIFIER)('a')
               PsiElement(COMMA)(',')
               PsiWhiteSpace(' ')
               VALUE_PARAMETER
                 PsiElement(IDENTIFIER)('b')
-              PsiElement(RPAR)(')')
             PsiWhiteSpace(' ')
             PsiElement(ARROW)('->')
             PsiWhiteSpace(' ')

compiler/testData/psi/examples/util/Comparison.kt

@@ -10,7 +10,7 @@ enum class ComparisonResult {
 
 typealias MatchableComparison<in T> =  (T, T) -> ComparisonResult
 
-fun asMatchableComparison<T>(cmp : Comparison<T>) : MatchableComparison<T> = {(a, b) ->
+fun asMatchableComparison<T>(cmp : Comparison<T>) : MatchableComparison<T> = {a, b ->
   val res = cmp(a, b)
   if (res == 0) return ComparisonResult.EQ
   if (res < 0) return ComparisonResult.LS

compiler/testData/psi/examples/util/Comparison.txt

@@ -324,14 +324,12 @@ JetFile: Comparison.kt
       FUNCTION_LITERAL
         PsiElement(LBRACE)('{')
         VALUE_PARAMETER_LIST
-          PsiElement(LPAR)('(')
           VALUE_PARAMETER
             PsiElement(IDENTIFIER)('a')
           PsiElement(COMMA)(',')
           PsiWhiteSpace(' ')
           VALUE_PARAMETER
             PsiElement(IDENTIFIER)('b')
-          PsiElement(RPAR)(')')
         PsiWhiteSpace(' ')
         PsiElement(ARROW)('->')
         PsiWhiteSpace('\n  ')

compiler/testData/psi/greatSyntacticShift/functionLiterals.kt

@@ -12,32 +12,7 @@ a(1
 , {-> 1}
 , {x -> 1}
 , {x, y -> 1}
-, {(x, y) -> 1}
+, {x -> 1}
-, {(x, y) : Int -> 1}
-, {(x) -> 1}
-, {(x) : Int -> 1}
 , {(x)}
-, {(x).(y)}
-, {x.(y)}
-, {Int.(x) -> 1}
-, {A.B.(x) -> 1}
-, {A.B.(x, y) -> 1}
-, {Int.(x) : Int -> 1}
-, {Int.(x, y) -> 1}
-, {Int.(x, y) : Int -> 1}
-, {(Int).(x, y) -> 1}
-, {(Int).(x, y) : Int -> 1}
-, {(Int).(x, y) : (Int) -> Int -> {1}}
-, {Int? .(x, y) -> 1}
-, {This.(x, y) -> 1}
-, {Pair(A, B).(x, y) -> 1}
-, {Pair(a, b).(y)}
-, {Pair(a, b)}
-, {Foo<Bar>.x}
-, {Foo<Bar>.(x)}
-, {Foo<Bar>.(x) -> x}
-, {Foo.Bar.Baz.(x) -> x}
-, {Foo<Bar>.(x) : Int -> x}
-, {Foo.Bar.Baz.(x) : Int -> x}
 )
 }

compiler/testData/psi/greatSyntacticShift/functionLiterals.txt

@@ -166,89 +166,8 @@ JetFile: functionLiterals.kt
               FUNCTION_LITERAL
                 PsiElement(LBRACE)('{')
                 VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
                   VALUE_PARAMETER
                     PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
                 PsiWhiteSpace(' ')
                 PsiElement(ARROW)('->')
                 PsiWhiteSpace(' ')
@@ -271,689 +190,6 @@ JetFile: functionLiterals.kt
                     PsiElement(RPAR)(')')
                 PsiElement(RBRACE)('}')
           PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  DOT_QUALIFIED_EXPRESSION
-                    PARENTHESIZED
-                      PsiElement(LPAR)('(')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-                      PsiElement(RPAR)(')')
-                    PsiElement(DOT)('.')
-                    PARENTHESIZED
-                      PsiElement(LPAR)('(')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('y')
-                      PsiElement(RPAR)(')')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  DOT_QUALIFIED_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('x')
-                    PsiElement(DOT)('.')
-                    PARENTHESIZED
-                      PsiElement(LPAR)('(')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('y')
-                      PsiElement(RPAR)(')')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('A')
-                    PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('B')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('A')
-                    PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('B')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  PsiElement(LPAR)('(')
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                  PsiElement(RPAR)(')')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  PsiElement(LPAR)('(')
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                  PsiElement(RPAR)(')')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  PsiElement(LPAR)('(')
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                  PsiElement(RPAR)(')')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  FUNCTION_TYPE
-                    VALUE_PARAMETER_LIST
-                      PsiElement(LPAR)('(')
-                      VALUE_PARAMETER
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('Int')
-                      PsiElement(RPAR)(')')
-                    PsiWhiteSpace(' ')
-                    PsiElement(ARROW)('->')
-                    PsiWhiteSpace(' ')
-                    TYPE_REFERENCE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  FUNCTION_LITERAL_EXPRESSION
-                    FUNCTION_LITERAL
-                      PsiElement(LBRACE)('{')
-                      BLOCK
-                        INTEGER_CONSTANT
-                          PsiElement(INTEGER_LITERAL)('1')
-                      PsiElement(RBRACE)('}')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  NULLABLE_TYPE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Int')
-                    PsiElement(QUEST)('?')
-                PsiWhiteSpace(' ')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  SELF_TYPE
-                    PsiElement(This)('This')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(COMMA)(',')
-                  PsiWhiteSpace(' ')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('y')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  INTEGER_CONSTANT
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  DOT_QUALIFIED_EXPRESSION
-                    CALL_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Pair')
-                      VALUE_ARGUMENT_LIST
-                        PsiElement(LPAR)('(')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('A')
-                        PsiElement(COMMA)(',')
-                        PsiWhiteSpace(' ')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('B')
-                        PsiElement(RPAR)(')')
-                    PsiElement(DOT)('.')
-                    PARENTHESIZED
-                      PsiElement(LPAR)('(')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-                      PsiErrorElement:Expecting ')'
-                        <empty list>
-                  PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-                    PsiElement(COMMA)(',')
-                    PsiWhiteSpace(' ')
-                    PsiElement(IDENTIFIER)('y')
-                    PsiElement(RPAR)(')')
-                    PsiWhiteSpace(' ')
-                    PsiElement(ARROW)('->')
-                    PsiWhiteSpace(' ')
-                    PsiElement(INTEGER_LITERAL)('1')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  DOT_QUALIFIED_EXPRESSION
-                    CALL_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Pair')
-                      VALUE_ARGUMENT_LIST
-                        PsiElement(LPAR)('(')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('a')
-                        PsiElement(COMMA)(',')
-                        PsiWhiteSpace(' ')
-                        VALUE_ARGUMENT
-                          REFERENCE_EXPRESSION
-                            PsiElement(IDENTIFIER)('b')
-                        PsiElement(RPAR)(')')
-                    PsiElement(DOT)('.')
-                    PARENTHESIZED
-                      PsiElement(LPAR)('(')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('y')
-                      PsiElement(RPAR)(')')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  CALL_EXPRESSION
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Pair')
-                    VALUE_ARGUMENT_LIST
-                      PsiElement(LPAR)('(')
-                      VALUE_ARGUMENT
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('a')
-                      PsiElement(COMMA)(',')
-                      PsiWhiteSpace(' ')
-                      VALUE_ARGUMENT
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('b')
-                      PsiElement(RPAR)(')')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  DOT_QUALIFIED_EXPRESSION
-                    CALL_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Foo')
-                      TYPE_ARGUMENT_LIST
-                        PsiElement(LT)('<')
-                        TYPE_PROJECTION
-                          TYPE_REFERENCE
-                            USER_TYPE
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('Bar')
-                        PsiElement(GT)('>')
-                    PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('x')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                BLOCK
-                  DOT_QUALIFIED_EXPRESSION
-                    CALL_EXPRESSION
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Foo')
-                      TYPE_ARGUMENT_LIST
-                        PsiElement(LT)('<')
-                        TYPE_PROJECTION
-                          TYPE_REFERENCE
-                            USER_TYPE
-                              REFERENCE_EXPRESSION
-                                PsiElement(IDENTIFIER)('Bar')
-                        PsiElement(GT)('>')
-                    PsiElement(DOT)('.')
-                    PARENTHESIZED
-                      PsiElement(LPAR)('(')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('x')
-                      PsiElement(RPAR)(')')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Foo')
-                    TYPE_ARGUMENT_LIST
-                      PsiElement(LT)('<')
-                      TYPE_PROJECTION
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('Bar')
-                      PsiElement(GT)('>')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('x')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    USER_TYPE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Foo')
-                      PsiElement(DOT)('.')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Bar')
-                    PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Baz')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('x')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Foo')
-                    TYPE_ARGUMENT_LIST
-                      PsiElement(LT)('<')
-                      TYPE_PROJECTION
-                        TYPE_REFERENCE
-                          USER_TYPE
-                            REFERENCE_EXPRESSION
-                              PsiElement(IDENTIFIER)('Bar')
-                      PsiElement(GT)('>')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('x')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
-          PsiElement(COMMA)(',')
-          PsiWhiteSpace(' ')
-          VALUE_ARGUMENT
-            FUNCTION_LITERAL_EXPRESSION
-              FUNCTION_LITERAL
-                PsiElement(LBRACE)('{')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    USER_TYPE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('Foo')
-                      PsiElement(DOT)('.')
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('Bar')
-                    PsiElement(DOT)('.')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Baz')
-                PsiElement(DOT)('.')
-                VALUE_PARAMETER_LIST
-                  PsiElement(LPAR)('(')
-                  VALUE_PARAMETER
-                    PsiElement(IDENTIFIER)('x')
-                  PsiElement(RPAR)(')')
-                PsiWhiteSpace(' ')
-                PsiElement(COLON)(':')
-                PsiWhiteSpace(' ')
-                TYPE_REFERENCE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('Int')
-                PsiWhiteSpace(' ')
-                PsiElement(ARROW)('->')
-                PsiWhiteSpace(' ')
-                BLOCK
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('x')
-                PsiElement(RBRACE)('}')
-          PsiWhiteSpace('\n')
           PsiElement(RPAR)(')')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')

grammar/src/expressions.grm

@@ -256,7 +256,6 @@ jump
 functionLiteral
   : "{" statements "}"
   : "{" (modifiers SimpleName){","} "->" statements "}"
-  : "{" (type ".")? "(" (modifiers SimpleName (":" type)?){","} ")" (":" type)? "->" statements "}"
   ;
 
 statements

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt

@@ -64,7 +64,7 @@ fun createModuleResolverProvider(
         val resolverForProject = analyzerFacade.setupResolverForProject(
                 globalContext.withProject(project), modulesToCreateResolversFor, modulesContent,
                 jvmPlatformParameters, IdeaEnvironment, delegateResolver,
-                { (m, c) -> IDEPackagePartProvider(c.moduleContentScope) }
+                { m, c -> IDEPackagePartProvider(c.moduleContentScope) }
         )
         return resolverForProject
     }