Parse expressions on LHS of '::'

See https://github.com/Kotlin/KEEP/issues/5

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

@@ -366,54 +366,60 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
     }
 
     /*
-     * callableReference
+     * doubleColonSuffix
-     *   : (userType "?"*)? "::" SimpleName typeArguments?
+     *   : "::" SimpleName typeArguments?
      *   ;
      */
-    private boolean parseDoubleColonExpression() {
+    private boolean parseDoubleColonSuffix(@NotNull PsiBuilder.Marker expression) {
-        PsiBuilder.Marker expression = mark();
+        if (!at(COLONCOLON)) return false;
-
-        if (!at(COLONCOLON)) {
-            PsiBuilder.Marker typeReference = mark();
-            myKotlinParsing.parseUserType();
-            typeReference = myKotlinParsing.parseNullableTypeSuffix(typeReference);
-            typeReference.done(TYPE_REFERENCE);
-
-            if (!at(COLONCOLON)) {
-                expression.rollbackTo();
-                return false;
-            }
-        }
 
         advance(); // COLONCOLON
 
         if (at(CLASS_KEYWORD)) {
             advance(); // CLASS_KEYWORD
-            expression.done(CLASS_LITERAL_EXPRESSION);
-        }
-        else {
-            parseSimpleNameExpression();
 
-            if (at(LT)) {
+            expression.done(CLASS_LITERAL_EXPRESSION);
-                PsiBuilder.Marker typeArgumentList = mark();
+            return true;
-                if (myKotlinParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) {
+        }
-                    typeArgumentList.error("Type arguments are not allowed");
+
-                }
+        parseSimpleNameExpression();
-                else {
+
-                    typeArgumentList.rollbackTo();
+        if (at(LT)) {
+            PsiBuilder.Marker typeArgumentList = mark();
+            if (myKotlinParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) {
+                typeArgumentList.error("Type arguments are not allowed");
+            }
+            else {
+                typeArgumentList.rollbackTo();
+            }
+        }
+
+        if (at(LPAR) && !myBuilder.newlineBeforeCurrentToken()) {
+            PsiBuilder.Marker lpar = mark();
+            parseCallSuffix();
+            lpar.error("This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)");
+        }
+
+        expression.done(CALLABLE_REFERENCE_EXPRESSION);
+        return true;
+    }
+
+    private void skipQuestionMarksBeforeDoubleColon() {
+        if (at(QUEST)) {
+            int k = 1;
+            while (lookahead(k) == QUEST) k++;
+            if (lookahead(k) == COLONCOLON) {
+                while (k > 0) {
+                    advance(); // QUEST
+                    k--;
                 }
             }
-
-            expression.done(CALLABLE_REFERENCE_EXPRESSION);
         }
-
-        return true;
     }
 
     /*
      * postfixUnaryExpression
      *   : atomicExpression postfixUnaryOperation*
-     *   : callableReference postfixUnaryOperation*
      *   ;
      *
      * postfixUnaryOperation
@@ -427,14 +433,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
     private void parsePostfixExpression() {
         PsiBuilder.Marker expression = mark();
 
-        boolean firstExpressionParsed;
+        boolean firstExpressionParsed = at(COLONCOLON) ? parseDoubleColonSuffix(mark()) : parseAtomicExpression();
-        boolean doubleColonExpression = parseDoubleColonExpression();
-        if (!doubleColonExpression) {
-            firstExpressionParsed = parseAtomicExpression();
-        }
-        else {
-            firstExpressionParsed = true;
-        }
 
         while (true) {
             if (interruptedWithNewLine()) {
@@ -444,7 +443,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
                 parseArrayAccess();
                 expression.done(ARRAY_ACCESS_EXPRESSION);
             }
-            else if (!doubleColonExpression && parseCallSuffix()) {
+            else if (parseCallSuffix()) {
                 expression.done(CALL_EXPRESSION);
             }
             else if (at(DOT) || at(SAFE_ACCESS)) {
@@ -471,7 +470,10 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
                 expression.done(POSTFIX_EXPRESSION);
             }
             else {
-                break;
+                skipQuestionMarksBeforeDoubleColon();
+                if (!parseDoubleColonSuffix(expression)) {
+                    break;
+                }
             }
             expression = expression.precede();
         }

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

@@ -57,7 +57,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
     private static final TokenSet PARAMETER_NAME_RECOVERY_SET = TokenSet.create(COLON, EQ, COMMA, RPAR);
     private static final TokenSet PACKAGE_NAME_RECOVERY_SET = TokenSet.create(DOT, EOL_OR_SEMICOLON);
     private static final TokenSet IMPORT_RECOVERY_SET = TokenSet.create(AS_KEYWORD, DOT, EOL_OR_SEMICOLON);
-    /*package*/ static final TokenSet TYPE_REF_FIRST = TokenSet.create(LBRACKET, IDENTIFIER, LPAR, HASH, DYNAMIC_KEYWORD);
+    private static final TokenSet TYPE_REF_FIRST = TokenSet.create(LBRACKET, IDENTIFIER, LPAR, HASH, DYNAMIC_KEYWORD);
     private static final TokenSet RECEIVER_TYPE_TERMINATORS = TokenSet.create(DOT, SAFE_ACCESS);
     private static final TokenSet VALUE_PARAMETER_FIRST =
             TokenSet.orSet(TokenSet.create(IDENTIFIER, LBRACKET, VAL_KEYWORD, VAR_KEYWORD), MODIFIER_KEYWORDS);
@@ -779,7 +779,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
      *   : "object" SimpleName? primaryConstructor? ":" delegationSpecifier{","}? classBody?
      *   ;
      */
-    IElementType parseClassOrObject(
+    private IElementType parseClassOrObject(
             boolean object,
             NameParsingMode nameParsingMode,
             boolean optionalBody,
@@ -1641,7 +1641,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
     /*
      * delegationSpecifier{","}
      */
-    /*package*/ void parseDelegationSpecifierList() {
+    private void parseDelegationSpecifierList() {
         PsiBuilder.Marker list = mark();
 
         while (true) {
@@ -1926,7 +1926,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
     }
 
     @NotNull
-    PsiBuilder.Marker parseNullableTypeSuffix(@NotNull PsiBuilder.Marker typeElementMarker) {
+    private PsiBuilder.Marker parseNullableTypeSuffix(@NotNull PsiBuilder.Marker typeElementMarker) {
         // ?: is joined regardless of joining state
         while (at(QUEST) && myBuilder.rawLookup(1) != COLON) {
             PsiBuilder.Marker precede = typeElementMarker.precede();
@@ -1947,7 +1947,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
      *    - (Mutable)List<Foo>!
      *    - Array<(out) Foo>!
      */
-    void parseUserType() {
+    private void parseUserType() {
         PsiBuilder.Marker userType = mark();
 
         if (at(PACKAGE_KEYWORD)) {
@@ -2122,7 +2122,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
      *   : parameter ("=" element)?
      *   ;
      */
-    void parseValueParameterList(boolean isFunctionTypeContents, boolean typeRequired, TokenSet recoverySet) {
+    private void parseValueParameterList(boolean isFunctionTypeContents, boolean typeRequired, TokenSet recoverySet) {
         assert _at(LPAR);
         PsiBuilder.Marker parameters = mark();
 

compiler/testData/psi/DoubleColon.kt

@@ -37,4 +37,29 @@ fun classLiteral() {
     a<b,c>::class
     ::class
     a b ::class
+
+    this::class
+    super::class
+    X()::class
+    object {}::class
+}
+
+fun expressions() {
+    this@x::foo
+    super<a>@b::foo
+
+    -a::b
+    ++a::b
+    a+b::c
+    (a+b)::c
+    x()::e
+    x().y().z()::e
+
+    a::b.c::d
+    A::a::b
+}
+
+fun emptyLHS() {
+    ::x.name
+    foo(::x.name)
 }

compiler/testData/psi/DoubleColon.txt

@@ -15,20 +15,16 @@ JetFile: DoubleColon.kt
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          USER_TYPE
+          PsiElement(IDENTIFIER)('A')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('A')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('a')
       PsiWhiteSpace('\n    ')
       BINARY_EXPRESSION
         CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('A')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('A')
           PsiElement(COLONCOLON)('::')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('a')
@@ -40,25 +36,24 @@ JetFile: DoubleColon.kt
           PsiElement(INTEGER_LITERAL)('1')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        CALL_EXPRESSION
-          USER_TYPE
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('Map')
-              PsiElement(IDENTIFIER)('Map')
+          TYPE_ARGUMENT_LIST
-            TYPE_ARGUMENT_LIST
+            PsiElement(LT)('<')
-              PsiElement(LT)('<')
+            TYPE_PROJECTION
-              TYPE_PROJECTION
+              TYPE_REFERENCE
-                TYPE_REFERENCE
+                USER_TYPE
-                  USER_TYPE
+                  REFERENCE_EXPRESSION
-                    REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('String')
-                      PsiElement(IDENTIFIER)('String')
+            PsiElement(COMMA)(',')
-              PsiElement(COMMA)(',')
+            PsiWhiteSpace(' ')
-              PsiWhiteSpace(' ')
+            TYPE_PROJECTION
-              TYPE_PROJECTION
+              TYPE_REFERENCE
-                TYPE_REFERENCE
+                USER_TYPE
-                  USER_TYPE
+                  REFERENCE_EXPRESSION
-                    REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Int')
-                      PsiElement(IDENTIFIER)('Int')
+            PsiElement(GT)('>')
-              PsiElement(GT)('>')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('size')
@@ -69,24 +64,20 @@ JetFile: DoubleColon.kt
           PsiElement(IDENTIFIER)('a')
       PsiWhiteSpace('\n\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        DOT_QUALIFIED_EXPRESSION
-          USER_TYPE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+          PsiElement(DOT)('.')
-                PsiElement(IDENTIFIER)('a')
+          REFERENCE_EXPRESSION
-            PsiElement(DOT)('.')
+            PsiElement(IDENTIFIER)('b')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('c')
       PsiWhiteSpace('\n    ')
       DOT_QUALIFIED_EXPRESSION
         CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
           PsiElement(COLONCOLON)('::')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('b')
@@ -96,14 +87,12 @@ JetFile: DoubleColon.kt
       PsiWhiteSpace('\n    ')
       DOT_QUALIFIED_EXPRESSION
         CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
+          DOT_QUALIFIED_EXPRESSION
-            USER_TYPE
+            REFERENCE_EXPRESSION
-              USER_TYPE
+              PsiElement(IDENTIFIER)('a')
-                REFERENCE_EXPRESSION
+            PsiElement(DOT)('.')
-                  PsiElement(IDENTIFIER)('a')
+            REFERENCE_EXPRESSION
-              PsiElement(DOT)('.')
+              PsiElement(IDENTIFIER)('b')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('b')
           PsiElement(COLONCOLON)('::')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('c')
@@ -115,10 +104,8 @@ JetFile: DoubleColon.kt
         PARENTHESIZED
           PsiElement(LPAR)('(')
           CALLABLE_REFERENCE_EXPRESSION
-            TYPE_REFERENCE
+            REFERENCE_EXPRESSION
-              USER_TYPE
+              PsiElement(IDENTIFIER)('a')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
             PsiElement(COLONCOLON)('::')
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('b')
@@ -135,10 +122,8 @@ JetFile: DoubleColon.kt
           PARENTHESIZED
             PsiElement(LPAR)('(')
             CALLABLE_REFERENCE_EXPRESSION
-              TYPE_REFERENCE
+              REFERENCE_EXPRESSION
-                USER_TYPE
+                PsiElement(IDENTIFIER)('b')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
               PsiElement(COLONCOLON)('::')
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('c')
@@ -161,8 +146,24 @@ JetFile: DoubleColon.kt
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        CALL_EXPRESSION
-          USER_TYPE
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+          TYPE_ARGUMENT_LIST
+            PsiElement(LT)('<')
+            TYPE_PROJECTION
+              TYPE_REFERENCE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('b')
+            PsiElement(GT)('>')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('c')
+      PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        CALLABLE_REFERENCE_EXPRESSION
+          CALL_EXPRESSION
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('a')
             TYPE_ARGUMENT_LIST
@@ -173,24 +174,6 @@ JetFile: DoubleColon.kt
                     REFERENCE_EXPRESSION
                       PsiElement(IDENTIFIER)('b')
               PsiElement(GT)('>')
-        PsiElement(COLONCOLON)('::')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('c')
-      PsiWhiteSpace('\n    ')
-      DOT_QUALIFIED_EXPRESSION
-        CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-              TYPE_ARGUMENT_LIST
-                PsiElement(LT)('<')
-                TYPE_PROJECTION
-                  TYPE_REFERENCE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('b')
-                PsiElement(GT)('>')
           PsiElement(COLONCOLON)('::')
           REFERENCE_EXPRESSION
             PsiElement(IDENTIFIER)('c')
@@ -199,12 +182,11 @@ JetFile: DoubleColon.kt
           PsiElement(IDENTIFIER)('d')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        DOT_QUALIFIED_EXPRESSION
-          USER_TYPE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+          PsiElement(DOT)('.')
-                PsiElement(IDENTIFIER)('a')
+          CALL_EXPRESSION
-            PsiElement(DOT)('.')
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('b')
             TYPE_ARGUMENT_LIST
@@ -221,12 +203,11 @@ JetFile: DoubleColon.kt
       PsiWhiteSpace('\n    ')
       DOT_QUALIFIED_EXPRESSION
         CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
+          DOT_QUALIFIED_EXPRESSION
-            USER_TYPE
+            REFERENCE_EXPRESSION
-              USER_TYPE
+              PsiElement(IDENTIFIER)('a')
-                REFERENCE_EXPRESSION
+            PsiElement(DOT)('.')
-                  PsiElement(IDENTIFIER)('a')
+            CALL_EXPRESSION
-              PsiElement(DOT)('.')
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('b')
               TYPE_ARGUMENT_LIST
@@ -245,12 +226,11 @@ JetFile: DoubleColon.kt
           PsiElement(IDENTIFIER)('e')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        DOT_QUALIFIED_EXPRESSION
-          USER_TYPE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+          PsiElement(DOT)('.')
-                PsiElement(IDENTIFIER)('a')
+          CALL_EXPRESSION
-            PsiElement(DOT)('.')
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('b')
             TYPE_ARGUMENT_LIST
@@ -271,12 +251,11 @@ JetFile: DoubleColon.kt
       PsiWhiteSpace('\n    ')
       DOT_QUALIFIED_EXPRESSION
         CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
+          DOT_QUALIFIED_EXPRESSION
-            USER_TYPE
+            REFERENCE_EXPRESSION
-              USER_TYPE
+              PsiElement(IDENTIFIER)('a')
-                REFERENCE_EXPRESSION
+            PsiElement(DOT)('.')
-                  PsiElement(IDENTIFIER)('a')
+            CALL_EXPRESSION
-              PsiElement(DOT)('.')
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('b')
               TYPE_ARGUMENT_LIST
@@ -300,12 +279,11 @@ JetFile: DoubleColon.kt
       PsiWhiteSpace('\n    ')
       DOT_QUALIFIED_EXPRESSION
         CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
+          DOT_QUALIFIED_EXPRESSION
-            USER_TYPE
+            REFERENCE_EXPRESSION
-              USER_TYPE
+              PsiElement(IDENTIFIER)('a')
-                REFERENCE_EXPRESSION
+            PsiElement(DOT)('.')
-                  PsiElement(IDENTIFIER)('a')
+            CALL_EXPRESSION
-              PsiElement(DOT)('.')
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('b')
               TYPE_ARGUMENT_LIST
@@ -340,18 +318,17 @@ JetFile: DoubleColon.kt
           PsiElement(IDENTIFIER)('h')
       PsiWhiteSpace('\n\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        DOT_QUALIFIED_EXPRESSION
-          USER_TYPE
+          DOT_QUALIFIED_EXPRESSION
-            USER_TYPE
+            DOT_QUALIFIED_EXPRESSION
-              USER_TYPE
+              DOT_QUALIFIED_EXPRESSION
-                USER_TYPE
+                REFERENCE_EXPRESSION
-                  USER_TYPE
+                  PsiElement(IDENTIFIER)('a')
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('a')
-                  PsiElement(DOT)('.')
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('b')
                 PsiElement(DOT)('.')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('b')
+              PsiElement(DOT)('.')
+              CALL_EXPRESSION
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('c')
                 TYPE_ARGUMENT_LIST
@@ -362,7 +339,8 @@ JetFile: DoubleColon.kt
                         REFERENCE_EXPRESSION
                           PsiElement(IDENTIFIER)('d')
                   PsiElement(GT)('>')
-              PsiElement(DOT)('.')
+            PsiElement(DOT)('.')
+            CALL_EXPRESSION
               REFERENCE_EXPRESSION
                 PsiElement(IDENTIFIER)('e')
               TYPE_ARGUMENT_LIST
@@ -373,9 +351,9 @@ JetFile: DoubleColon.kt
                       REFERENCE_EXPRESSION
                         PsiElement(IDENTIFIER)('f')
                 PsiElement(GT)('>')
-            PsiElement(DOT)('.')
+          PsiElement(DOT)('.')
-            REFERENCE_EXPRESSION
+          REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('g')
+            PsiElement(IDENTIFIER)('g')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('h')
@@ -394,73 +372,62 @@ JetFile: DoubleColon.kt
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          NULLABLE_TYPE
+          PsiElement(IDENTIFIER)('a')
-            USER_TYPE
+        PsiElement(QUEST)('?')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('b')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          NULLABLE_TYPE
+          PsiElement(IDENTIFIER)('a')
-            NULLABLE_TYPE
+        PsiElement(QUEST)('?')
-              USER_TYPE
+        PsiElement(QUEST)('?')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('a')
-              PsiElement(QUEST)('?')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('b')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        CALL_EXPRESSION
-          NULLABLE_TYPE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+          TYPE_ARGUMENT_LIST
-                PsiElement(IDENTIFIER)('a')
+            PsiElement(LT)('<')
-              TYPE_ARGUMENT_LIST
+            TYPE_PROJECTION
-                PsiElement(LT)('<')
+              TYPE_REFERENCE
-                TYPE_PROJECTION
+                USER_TYPE
-                  TYPE_REFERENCE
+                  REFERENCE_EXPRESSION
-                    USER_TYPE
+                    PsiElement(IDENTIFIER)('b')
-                      REFERENCE_EXPRESSION
+            PsiElement(GT)('>')
-                        PsiElement(IDENTIFIER)('b')
+        PsiElement(QUEST)('?')
-                PsiElement(GT)('>')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('c')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        CALL_EXPRESSION
-          NULLABLE_TYPE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+          TYPE_ARGUMENT_LIST
-                PsiElement(IDENTIFIER)('a')
+            PsiElement(LT)('<')
-              TYPE_ARGUMENT_LIST
+            TYPE_PROJECTION
-                PsiElement(LT)('<')
+              TYPE_REFERENCE
-                TYPE_PROJECTION
+                NULLABLE_TYPE
-                  TYPE_REFERENCE
+                  USER_TYPE
-                    NULLABLE_TYPE
+                    REFERENCE_EXPRESSION
-                      USER_TYPE
+                      PsiElement(IDENTIFIER)('b')
-                        REFERENCE_EXPRESSION
+                  PsiElement(QUEST)('?')
-                          PsiElement(IDENTIFIER)('b')
+            PsiElement(COMMA)(',')
-                      PsiElement(QUEST)('?')
+            TYPE_PROJECTION
-                PsiElement(COMMA)(',')
+              TYPE_REFERENCE
-                TYPE_PROJECTION
+                NULLABLE_TYPE
-                  TYPE_REFERENCE
+                  USER_TYPE
-                    NULLABLE_TYPE
+                    REFERENCE_EXPRESSION
-                      USER_TYPE
+                      PsiElement(IDENTIFIER)('c')
-                        REFERENCE_EXPRESSION
+                  PsiElement(QUEST)('?')
-                          PsiElement(IDENTIFIER)('c')
+            PsiElement(GT)('>')
-                      PsiElement(QUEST)('?')
+        PsiElement(QUEST)('?')
-                PsiElement(GT)('>')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('d')
@@ -479,32 +446,29 @@ JetFile: DoubleColon.kt
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       CLASS_LITERAL_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          USER_TYPE
+          PsiElement(IDENTIFIER)('A')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('A')
         PsiElement(COLONCOLON)('::')
         PsiElement(class)('class')
       PsiWhiteSpace('\n    ')
       CLASS_LITERAL_EXPRESSION
-        TYPE_REFERENCE
+        CALL_EXPRESSION
-          USER_TYPE
+          REFERENCE_EXPRESSION
-            REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
-              PsiElement(IDENTIFIER)('a')
+          TYPE_ARGUMENT_LIST
-            TYPE_ARGUMENT_LIST
+            PsiElement(LT)('<')
-              PsiElement(LT)('<')
+            TYPE_PROJECTION
-              TYPE_PROJECTION
+              TYPE_REFERENCE
-                TYPE_REFERENCE
+                USER_TYPE
-                  USER_TYPE
+                  REFERENCE_EXPRESSION
-                    REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('b')
-                      PsiElement(IDENTIFIER)('b')
+            PsiElement(COMMA)(',')
-              PsiElement(COMMA)(',')
+            TYPE_PROJECTION
-              TYPE_PROJECTION
+              TYPE_REFERENCE
-                TYPE_REFERENCE
+                USER_TYPE
-                  USER_TYPE
+                  REFERENCE_EXPRESSION
-                    REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('c')
-                      PsiElement(IDENTIFIER)('c')
+            PsiElement(GT)('>')
-              PsiElement(GT)('>')
         PsiElement(COLONCOLON)('::')
         PsiElement(class)('class')
       PsiWhiteSpace('\n    ')
@@ -522,5 +486,232 @@ JetFile: DoubleColon.kt
         CLASS_LITERAL_EXPRESSION
           PsiElement(COLONCOLON)('::')
           PsiElement(class)('class')
+      PsiWhiteSpace('\n\n    ')
+      CLASS_LITERAL_EXPRESSION
+        THIS_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(this)('this')
+        PsiElement(COLONCOLON)('::')
+        PsiElement(class)('class')
+      PsiWhiteSpace('\n    ')
+      CLASS_LITERAL_EXPRESSION
+        SUPER_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(super)('super')
+        PsiElement(COLONCOLON)('::')
+        PsiElement(class)('class')
+      PsiWhiteSpace('\n    ')
+      CLASS_LITERAL_EXPRESSION
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('X')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiElement(COLONCOLON)('::')
+        PsiElement(class)('class')
+      PsiWhiteSpace('\n    ')
+      CLASS_LITERAL_EXPRESSION
+        OBJECT_LITERAL
+          OBJECT_DECLARATION
+            PsiElement(object)('object')
+            PsiWhiteSpace(' ')
+            CLASS_BODY
+              PsiElement(LBRACE)('{')
+              PsiElement(RBRACE)('}')
+        PsiElement(COLONCOLON)('::')
+        PsiElement(class)('class')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('expressions')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        THIS_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(this)('this')
+          LABEL_QUALIFIER
+            LABEL
+              PsiElement(AT)('@')
+              PsiElement(IDENTIFIER)('x')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        SUPER_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(super)('super')
+          PsiElement(LT)('<')
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('a')
+          PsiElement(GT)('>')
+          LABEL_QUALIFIER
+            LABEL
+              PsiElement(AT)('@')
+              PsiElement(IDENTIFIER)('b')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+      PsiWhiteSpace('\n\n    ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(MINUS)('-')
+        CALLABLE_REFERENCE_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+          PsiElement(COLONCOLON)('::')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      PREFIX_EXPRESSION
+        OPERATION_REFERENCE
+          PsiElement(PLUSPLUS)('++')
+        CALLABLE_REFERENCE_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+          PsiElement(COLONCOLON)('::')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      BINARY_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        OPERATION_REFERENCE
+          PsiElement(PLUS)('+')
+        CALLABLE_REFERENCE_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('b')
+          PsiElement(COLONCOLON)('::')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('c')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        PARENTHESIZED
+          PsiElement(LPAR)('(')
+          BINARY_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+            OPERATION_REFERENCE
+              PsiElement(PLUS)('+')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('b')
+          PsiElement(RPAR)(')')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('c')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        CALL_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('x')
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('e')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        DOT_QUALIFIED_EXPRESSION
+          DOT_QUALIFIED_EXPRESSION
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('x')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+            PsiElement(DOT)('.')
+            CALL_EXPRESSION
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('y')
+              VALUE_ARGUMENT_LIST
+                PsiElement(LPAR)('(')
+                PsiElement(RPAR)(')')
+          PsiElement(DOT)('.')
+          CALL_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('z')
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('e')
+      PsiWhiteSpace('\n\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        DOT_QUALIFIED_EXPRESSION
+          CALLABLE_REFERENCE_EXPRESSION
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('a')
+            PsiElement(COLONCOLON)('::')
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('b')
+          PsiElement(DOT)('.')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('c')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('d')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        CALLABLE_REFERENCE_EXPRESSION
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('A')
+          PsiElement(COLONCOLON)('::')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('a')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('emptyLHS')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      DOT_QUALIFIED_EXPRESSION
+        CALLABLE_REFERENCE_EXPRESSION
+          PsiElement(COLONCOLON)('::')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('x')
+        PsiElement(DOT)('.')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('name')
+      PsiWhiteSpace('\n    ')
+      CALL_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('foo')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            DOT_QUALIFIED_EXPRESSION
+              CALLABLE_REFERENCE_EXPRESSION
+                PsiElement(COLONCOLON)('::')
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('x')
+              PsiElement(DOT)('.')
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('name')
+          PsiElement(RPAR)(')')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')

compiler/testData/psi/DoubleColonWhitespaces.kt

@@ -0,0 +1,17 @@
+fun tests() {
+    a:: b
+    a ::b
+    a :: b
+
+    a?:: b
+    a ?::b
+    a ?:: b
+    a? ::b
+    a ? :: b
+    a ? ? :: b
+}
+
+fun breakLine() {
+    a?
+    ::b
+}

compiler/testData/psi/DoubleColonWhitespaces.txt

@@ -0,0 +1,125 @@
+JetFile: DoubleColonWhitespaces.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('tests')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiElement(COLONCOLON)('::')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(COLONCOLON)('::')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiElement(QUEST)('?')
+        PsiElement(COLONCOLON)('::')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(QUEST)('?')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(QUEST)('?')
+        PsiElement(COLONCOLON)('::')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiElement(QUEST)('?')
+        PsiWhiteSpace(' ')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(QUEST)('?')
+        PsiWhiteSpace(' ')
+        PsiElement(COLONCOLON)('::')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiWhiteSpace(' ')
+        PsiElement(QUEST)('?')
+        PsiWhiteSpace(' ')
+        PsiElement(QUEST)('?')
+        PsiWhiteSpace(' ')
+        PsiElement(COLONCOLON)('::')
+        PsiWhiteSpace(' ')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('breakLine')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('a')
+        PsiElement(QUEST)('?')
+        PsiWhiteSpace('\n    ')
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('b')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/DoubleColon_ERR.kt

@@ -14,6 +14,14 @@ fun err3() {
     ::
 }
 
+fun err4() {
+    ::x()
+}
+
+fun err5() {
+    ::x()()
+}
+
 fun typeArgumentsError() {
     ::a<b>
     ::a<b,c<*>>
@@ -21,8 +29,3 @@ fun typeArgumentsError() {
 
     ::a<b>()
 }
-
-fun expressionsOnLHS() {
-    a::b.c::d
-    A::a::b
-}

compiler/testData/psi/DoubleColon_ERR.txt

@@ -15,16 +15,15 @@ JetFile: DoubleColon_ERR.kt
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          USER_TYPE
+          PsiElement(IDENTIFIER)('a')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('b')
-      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+        PsiErrorElement:This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)
-        PsiElement(LPAR)('(')
+          VALUE_ARGUMENT_LIST
-        PsiElement(RPAR)(')')
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
@@ -40,20 +39,19 @@ JetFile: DoubleColon_ERR.kt
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        DOT_QUALIFIED_EXPRESSION
-          USER_TYPE
+          REFERENCE_EXPRESSION
-            USER_TYPE
+            PsiElement(IDENTIFIER)('a')
-              REFERENCE_EXPRESSION
+          PsiElement(DOT)('.')
-                PsiElement(IDENTIFIER)('a')
+          REFERENCE_EXPRESSION
-            PsiElement(DOT)('.')
+            PsiElement(IDENTIFIER)('b')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('b')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('c')
-      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+        PsiErrorElement:This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)
-        PsiElement(LPAR)('(')
+          VALUE_ARGUMENT_LIST
-        PsiElement(RPAR)(')')
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
@@ -69,10 +67,8 @@ JetFile: DoubleColon_ERR.kt
       PsiElement(LBRACE)('{')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          USER_TYPE
+          PsiElement(IDENTIFIER)('A')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('A')
         PsiElement(COLONCOLON)('::')
         PsiWhiteSpace('\n')
         REFERENCE_EXPRESSION
@@ -99,6 +95,54 @@ JetFile: DoubleColon_ERR.kt
             <empty list>
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('err4')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CALLABLE_REFERENCE_EXPRESSION
+        PsiElement(COLONCOLON)('::')
+        REFERENCE_EXPRESSION
+          PsiElement(IDENTIFIER)('x')
+        PsiErrorElement:This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)
+          VALUE_ARGUMENT_LIST
+            PsiElement(LPAR)('(')
+            PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('err5')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiWhiteSpace('\n    ')
+      CALL_EXPRESSION
+        CALLABLE_REFERENCE_EXPRESSION
+          PsiElement(COLONCOLON)('::')
+          REFERENCE_EXPRESSION
+            PsiElement(IDENTIFIER)('x')
+          PsiErrorElement:This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)
+            VALUE_ARGUMENT_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          PsiElement(RPAR)(')')
+      PsiWhiteSpace('\n')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
   FUN
     PsiElement(fun)('fun')
     PsiWhiteSpace(' ')
@@ -148,10 +192,8 @@ JetFile: DoubleColon_ERR.kt
           PsiElement(GT)('>')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          USER_TYPE
+          PsiElement(IDENTIFIER)('a')
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('a')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('b')
@@ -176,49 +218,9 @@ JetFile: DoubleColon_ERR.kt
                 REFERENCE_EXPRESSION
                   PsiElement(IDENTIFIER)('b')
           PsiElement(GT)('>')
-      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
+        PsiErrorElement:This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)
-        PsiElement(LPAR)('(')
+          VALUE_ARGUMENT_LIST
-        PsiElement(RPAR)(')')
+            PsiElement(LPAR)('(')
-      PsiWhiteSpace('\n')
+            PsiElement(RPAR)(')')
-      PsiElement(RBRACE)('}')
-  PsiWhiteSpace('\n\n')
-  FUN
-    PsiElement(fun)('fun')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('expressionsOnLHS')
-    VALUE_PARAMETER_LIST
-      PsiElement(LPAR)('(')
-      PsiElement(RPAR)(')')
-    PsiWhiteSpace(' ')
-    BLOCK
-      PsiElement(LBRACE)('{')
-      PsiWhiteSpace('\n    ')
-      DOT_QUALIFIED_EXPRESSION
-        CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-          PsiElement(COLONCOLON)('::')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('b')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('c')
-      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-        PsiElement(COLONCOLON)('::')
-        PsiElement(IDENTIFIER)('d')
-      PsiWhiteSpace('\n    ')
-      CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
-          USER_TYPE
-            REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('A')
-        PsiElement(COLONCOLON)('::')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('a')
-      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-        PsiElement(COLONCOLON)('::')
-        PsiElement(IDENTIFIER)('b')
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')

compiler/testData/psi/DynamicSoftKeyword.txt

@@ -69,10 +69,8 @@ JetFile: DynamicSoftKeyword.kt
               PsiElement(INTEGER_LITERAL)('1')
           PsiWhiteSpace('\n        ')
           CALLABLE_REFERENCE_EXPRESSION
-            TYPE_REFERENCE
+            REFERENCE_EXPRESSION
-              USER_TYPE
+              PsiElement(IDENTIFIER)('dynamic')
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('dynamic')
             PsiElement(COLONCOLON)('::')
             REFERENCE_EXPRESSION
               PsiElement(IDENTIFIER)('foo')

compiler/testData/psi/greatSyntacticShift/nullableTypes.txt

@@ -55,69 +55,51 @@ JetFile: nullableTypes.kt
           PsiElement(return)('return')
       PsiWhiteSpace('\n\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          NULLABLE_TYPE
+          PsiElement(IDENTIFIER)('X')
-            USER_TYPE
+        PsiElement(QUEST)('?')
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('X')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('x')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          NULLABLE_TYPE
+          PsiElement(IDENTIFIER)('X')
-            USER_TYPE
+        PsiWhiteSpace(' ')
-              REFERENCE_EXPRESSION
+        PsiElement(QUEST)('?')
-                PsiElement(IDENTIFIER)('X')
-            PsiWhiteSpace(' ')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         PsiWhiteSpace(' ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('x')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          NULLABLE_TYPE
+          PsiElement(IDENTIFIER)('X')
-            NULLABLE_TYPE
+        PsiElement(QUEST)('?')
-              USER_TYPE
+        PsiWhiteSpace(' ')
-                REFERENCE_EXPRESSION
+        PsiElement(QUEST)('?')
-                  PsiElement(IDENTIFIER)('X')
-              PsiElement(QUEST)('?')
-            PsiWhiteSpace(' ')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         PsiWhiteSpace(' ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('x')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          NULLABLE_TYPE
+          PsiElement(IDENTIFIER)('X')
-            NULLABLE_TYPE
+        PsiWhiteSpace(' ')
-              USER_TYPE
+        PsiElement(QUEST)('?')
-                REFERENCE_EXPRESSION
+        PsiElement(QUEST)('?')
-                  PsiElement(IDENTIFIER)('X')
-              PsiWhiteSpace(' ')
-              PsiElement(QUEST)('?')
-            PsiElement(QUEST)('?')
         PsiElement(COLONCOLON)('::')
         PsiWhiteSpace(' ')
         REFERENCE_EXPRESSION
           PsiElement(IDENTIFIER)('x')
       PsiWhiteSpace('\n    ')
       CALLABLE_REFERENCE_EXPRESSION
-        TYPE_REFERENCE
+        REFERENCE_EXPRESSION
-          NULLABLE_TYPE
+          PsiElement(IDENTIFIER)('X')
-            NULLABLE_TYPE
+        PsiWhiteSpace(' ')
-              USER_TYPE
+        PsiElement(QUEST)('?')
-                REFERENCE_EXPRESSION
+        PsiElement(QUEST)('?')
-                  PsiElement(IDENTIFIER)('X')
-              PsiWhiteSpace(' ')
-              PsiElement(QUEST)('?')
-            PsiElement(QUEST)('?')
         PsiWhiteSpace(' ')
         PsiElement(COLONCOLON)('::')
         PsiWhiteSpace(' ')

compiler/testData/psi/recovery/SameLineStatementRecovery.kt

@@ -21,10 +21,6 @@ fun f4() {
     val a1 = 12val b1 = 12
 }
 
-fun f5() {
-    a::b.c::d
-}
-
 fun f6() {
     3 + 4 33 1
 }

compiler/testData/psi/recovery/SameLineStatementRecovery.txt

@@ -222,35 +222,6 @@ JetFile: SameLineStatementRecovery.kt
       PsiWhiteSpace('\n')
       PsiElement(RBRACE)('}')
   PsiWhiteSpace('\n\n')
-  FUN
-    PsiElement(fun)('fun')
-    PsiWhiteSpace(' ')
-    PsiElement(IDENTIFIER)('f5')
-    VALUE_PARAMETER_LIST
-      PsiElement(LPAR)('(')
-      PsiElement(RPAR)(')')
-    PsiWhiteSpace(' ')
-    BLOCK
-      PsiElement(LBRACE)('{')
-      PsiWhiteSpace('\n    ')
-      DOT_QUALIFIED_EXPRESSION
-        CALLABLE_REFERENCE_EXPRESSION
-          TYPE_REFERENCE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('a')
-          PsiElement(COLONCOLON)('::')
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('b')
-        PsiElement(DOT)('.')
-        REFERENCE_EXPRESSION
-          PsiElement(IDENTIFIER)('c')
-      PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line)
-        PsiElement(COLONCOLON)('::')
-        PsiElement(IDENTIFIER)('d')
-      PsiWhiteSpace('\n')
-      PsiElement(RBRACE)('}')
-  PsiWhiteSpace('\n\n')
   FUN
     PsiElement(fun)('fun')
     PsiWhiteSpace(' ')

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

@@ -175,6 +175,12 @@ public class ParsingTestGenerated extends AbstractParsingTest {
             doParsingTest(fileName);
         }
 
+        @TestMetadata("DoubleColonWhitespaces.kt")
+        public void testDoubleColonWhitespaces() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/psi/DoubleColonWhitespaces.kt");
+            doParsingTest(fileName);
+        }
+
         @TestMetadata("DoubleColon_ERR.kt")
         public void testDoubleColon_ERR() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/psi/DoubleColon_ERR.kt");