Introduce JetCallableReferenceExpression

Reuse the obsolete hash qualified expression as a newly born callable reference
expression: Foo::bar. It's not a qualified expression anymore, since the
receiver part is now a JetTypeReference and it also can be empty ("::bar")

 #KT-1183 In Progress

compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java

@@ -131,6 +131,7 @@ public interface JetNodeTypes {
     JetNodeType ARRAY_ACCESS_EXPRESSION   = new JetNodeType("ARRAY_ACCESS_EXPRESSION", JetArrayAccessExpression.class);
     JetNodeType INDICES                   = new JetNodeType("INDICES", JetContainerNode.class);
     JetNodeType DOT_QUALIFIED_EXPRESSION  = new JetNodeType("DOT_QUALIFIED_EXPRESSION", JetDotQualifiedExpression.class);
+    JetNodeType CALLABLE_REFERENCE_EXPRESSION = new JetNodeType("CALLABLE_REFERENCE_EXPRESSION", JetCallableReferenceExpression.class);
     JetNodeType SAFE_ACCESS_EXPRESSION    = new JetNodeType("SAFE_ACCESS_EXPRESSION", JetSafeQualifiedExpression.class);
 
     JetNodeType OBJECT_LITERAL            = new JetNodeType("OBJECT_LITERAL", JetObjectLiteralExpression.class);

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -228,7 +228,6 @@ public class JetControlFlowProcessor {
                     visitAssignToArrayAccess(expression, arrayAccessExpression);
                 }
                 else if (left instanceof JetQualifiedExpression) {
-                    assert !(left instanceof JetHashQualifiedExpression) : left; // TODO
                     JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) left;
                     generateInstructions(qualifiedExpression.getReceiverExpression(), false);
                     generateInstructions(expression.getOperationReference(), false);

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCallableReferenceExpression.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.psi;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lexer.JetTokens;
+
+public class JetCallableReferenceExpression extends JetExpressionImpl {
+    public JetCallableReferenceExpression(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @Nullable
+    public JetTypeReference getTypeReference() {
+        return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE);
+    }
+
+    @NotNull
+    public JetSimpleNameExpression getCallableReference() {
+        ASTNode node = getNode().findChildByType(JetTokens.OPERATIONS /* TODO: COLONCOLON */);
+        while (node != null) {
+            PsiElement psi = node.getPsi();
+            if (psi instanceof JetSimpleNameExpression) {
+                return (JetSimpleNameExpression) psi;
+            }
+            node = node.getTreeNext();
+        }
+
+        throw new IllegalStateException("Callable reference simple name shouldn't be parsed to null");
+    }
+
+    @Override
+    public void accept(@NotNull JetVisitorVoid visitor) {
+        visitor.visitCallableReferenceExpression(this);
+    }
+
+    @Override
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+        return visitor.visitCallableReferenceExpression(this, data);
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetHashQualifiedExpression.java

@@ -1,36 +0,0 @@
-/*
- * Copyright 2010-2013 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.psi;
-
-import com.intellij.lang.ASTNode;
-import org.jetbrains.annotations.NotNull;
-
-public class JetHashQualifiedExpression extends JetQualifiedExpression {
-    public JetHashQualifiedExpression(@NotNull ASTNode node) {
-        super(node);
-    }
-
-    @Override
-    public void accept(@NotNull JetVisitorVoid visitor) {
-        visitor.visitHashQualifiedExpression(this);
-    }
-
-    @Override
-    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
-        return visitor.visitHashQualifiedExpression(this, data);
-    }
-}

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java

@@ -245,8 +245,8 @@ public class JetVisitor<R, D> extends PsiElementVisitor {
         return visitExpression(expression, data);
     }
 
-    public R visitHashQualifiedExpression(JetHashQualifiedExpression expression, D data) {
+    public R visitCallableReferenceExpression(JetCallableReferenceExpression expression, D data) {
-        return visitQualifiedExpression(expression, data);
+        return visitExpression(expression, data);
     }
 
     public R visitDotQualifiedExpression(JetDotQualifiedExpression expression, D data) {

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitorVoid.java

@@ -235,8 +235,8 @@ public class JetVisitorVoid extends PsiElementVisitor {
         visitExpression(expression);
     }
 
-    public void visitHashQualifiedExpression(JetHashQualifiedExpression expression) {
+    public void visitCallableReferenceExpression(JetCallableReferenceExpression expression) {
-        visitQualifiedExpression(expression);
+        visitExpression(expression);
     }
 
     public void visitDotQualifiedExpression(JetDotQualifiedExpression expression) {

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -563,7 +563,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitHashQualifiedExpression(JetHashQualifiedExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitCallableReferenceExpression(JetCallableReferenceExpression expression, ExpressionTypingContext context) {
         context.trace.report(UNSUPPORTED.on(expression, getClass().getCanonicalName()));
         return JetTypeInfo.create(null, context.dataFlowInfo);
     }