Replaced PrefixExpression with LabeledExpression

where labeled expression is used

Added 'visitLabeledExpression'

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -2917,23 +2917,21 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @Nullable
     private static JetSimpleNameExpression targetLabel(JetExpression expression) {
-        if (expression.getParent() instanceof JetPrefixExpression) {
+        if (expression.getParent() instanceof JetLabeledExpression) {
-            JetPrefixExpression parent = (JetPrefixExpression) expression.getParent();
+            return ((JetLabeledExpression) expression.getParent()).getTargetLabel();
-            JetSimpleNameExpression operationSign = parent.getOperationReference();
-            if (operationSign.getReferencedNameElementType() == JetTokens.LABEL_IDENTIFIER) {
-                return operationSign;
-            }
         }
         return null;
     }
 
     @Override
-    public StackValue visitPrefixExpression(@NotNull JetPrefixExpression expression, StackValue receiver) {
+    public StackValue visitLabeledExpression(
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
+            @NotNull JetLabeledExpression expression, StackValue receiver
-        if (operationSign.getReferencedNameElementType() == JetTokens.LABEL_IDENTIFIER) {
+    ) {
         return genQualified(receiver, expression.getBaseExpression());
     }
 
+    @Override
+    public StackValue visitPrefixExpression(@NotNull JetPrefixExpression expression, StackValue receiver) {
         DeclarationDescriptor op = bindingContext.get(REFERENCE_TARGET, expression.getOperationReference());
         assert op instanceof FunctionDescriptor : String.valueOf(op);
         Callable callable = resolveToCallable((FunctionDescriptor) op, false);

compiler/frontend/src/org/jetbrains/jet/checkers/DebugInfoUtil.java

@@ -96,9 +96,9 @@ public class DebugInfoUtil {
                         if (EXCLUDED.contains(referencedNameElementType)) {
                             return;
                         }
-                        if (referencedNameElementType == JetTokens.LABEL_IDENTIFIER) return;
                     }
-                    else if (nameExpression.getReferencedNameElementType() == JetTokens.THIS_KEYWORD) {
+                    if (elementType == JetNodeTypes.LABEL_REFERENCE ||
+                            nameExpression.getReferencedNameElementType() == JetTokens.THIS_KEYWORD) {
                         return;
                     }
                 }

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

@@ -229,18 +229,11 @@ public class JetControlFlowProcessor {
         }
 
         @Override
-        public void visitExpressionWithLabelVoid(@NotNull JetExpressionWithLabel expression, CFPContext context) {
+        public void visitLabeledExpressionVoid(@NotNull JetLabeledExpression expression, CFPContext context) {
-            String labelName = expression.getLabelName();
+            mark(expression);
-            JetExpression labeledExpression = expression.getLabeledExpression();
+            JetExpression baseExpression = expression.getBaseExpression();
-            if (labelName != null && labeledExpression != null) {
+            if (baseExpression != null) {
-                visitLabeledExpression(labelName, labeledExpression, context);
+                generateInstructions(baseExpression, context);
-            }
-        }
-
-        private void visitLabeledExpression(@NotNull String labelName, @NotNull JetExpression labeledExpression, CFPContext context) {
-            JetExpression deparenthesized = JetPsiUtil.deparenthesize(labeledExpression);
-            if (deparenthesized != null) {
-                generateInstructions(labeledExpression, context);
             }
         }
 
@@ -374,11 +367,7 @@ public class JetControlFlowProcessor {
             IElementType operationType = operationSign.getReferencedNameElementType();
             JetExpression baseExpression = expression.getBaseExpression();
             if (baseExpression == null) return;
-            if (operationType == JetTokens.LABEL_IDENTIFIER) {
+            if (JetTokens.EXCLEXCL == operationType) {
-                String referencedName = operationSign.getReferencedName();
-                visitLabeledExpression(referencedName.substring(1), baseExpression, context);
-            }
-            else if (JetTokens.EXCLEXCL == operationType) {
                 generateInstructions(baseExpression, NOT_IN_CONDITION);
                 builder.predefinedOperation(expression, NOT_NULL_ASSERTION);
             }

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -102,14 +102,12 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         return null
     }
 
-    override fun visitPrefixExpression(expression: JetPrefixExpression, expectedType: JetType?): CompileTimeConstant<*>? {
+    override fun visitLabeledExpression(expression: JetLabeledExpression, expectedType: JetType?): CompileTimeConstant<*>? {
-        val deparenthesizedExpression = JetPsiUtil.deparenthesize(expression)
+        val baseExpression = expression.getBaseExpression()
-        return if (deparenthesizedExpression != null && deparenthesizedExpression != expression) {
+        if (baseExpression != null) {
-            evaluate(deparenthesizedExpression, expectedType)
+            return evaluate(baseExpression, expectedType)
-        }
-        else {
-            super.visitPrefixExpression(expression, expectedType)
         }
+        return null
     }
 
     override fun visitStringTemplateExpression(expression: JetStringTemplateExpression, expectedType: JetType?): CompileTimeConstant<*>? {

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

@@ -76,13 +76,11 @@ public class JetCallExpression extends JetReferenceExpression implements JetCall
             if (psi instanceof JetFunctionLiteralExpression) {
                 result.add((JetFunctionLiteralExpression) psi);
             }
-            else if (psi instanceof JetPrefixExpression) {
+            else if (psi instanceof JetLabeledExpression) {
-                JetPrefixExpression prefixExpression = (JetPrefixExpression) psi;
+                JetLabeledExpression labeledExpression = (JetLabeledExpression) psi;
-                if (prefixExpression.getOperationReference().getReferencedNameElementType() == JetTokens.LABEL_IDENTIFIER) {
+                JetExpression baseExpression = labeledExpression.getBaseExpression();
-                    JetExpression labeledExpression = prefixExpression.getBaseExpression();
+                if (baseExpression instanceof JetFunctionLiteralExpression) {
-                    if (labeledExpression instanceof JetFunctionLiteralExpression) {
+                    result.add(labeledExpression);
-                        result.add(prefixExpression);
-                    }
                 }
             }
             node = node.getTreeNext();

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

@@ -34,15 +34,15 @@ public class JetExpressionWithLabel extends JetExpressionImpl {
         return (JetSimpleNameExpression) qualifier.findChildByType(JetNodeTypes.LABEL_REFERENCE);
     }
 
-    @Nullable @IfNotParsed
-    public JetExpression getLabeledExpression() {
-        return findChildByClass(JetExpression.class);
-    }
-
     @Nullable
     public String getLabelName() {
         JetSimpleNameExpression labelElement = getTargetLabel();
         assert labelElement == null || labelElement.getText().startsWith("@");
         return labelElement == null ? null : labelElement.getText().substring(1);
     }
+
+    @Override
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+        return visitor.visitExpressionWithLabel(this, data);
+    }
 }

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

@@ -47,4 +47,9 @@ public class JetLabeledExpression extends JetExpressionWithLabel {
     public JetExpression getBaseExpression() {
         return findChildByClass(JetExpression.class);
     }
+
+    @Override
+    public <R, D> R accept(@NotNull JetVisitor<R, D> visitor, D data) {
+        return visitor.visitLabeledExpression(this, data);
+    }
 }

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

@@ -107,8 +107,8 @@ public class JetPsiUtil {
                 }
             }
         }
-        else if (expression instanceof JetPrefixExpression) {
+        else if (expression instanceof JetLabeledExpression) {
-            JetExpression baseExpression = getBaseExpressionIfLabeledExpression((JetPrefixExpression) expression);
+            JetExpression baseExpression = ((JetLabeledExpression) expression).getBaseExpression();
             if (baseExpression != null) {
                 expression = baseExpression;
             }
@@ -124,26 +124,6 @@ public class JetPsiUtil {
         return expression;
     }
 
-    @Nullable
-    public static JetExpression getBaseExpressionIfLabeledExpression(@NotNull JetPrefixExpression expression) {
-        if (isLabeledExpression(expression)) {
-            return expression.getBaseExpression();
-        }
-        return null;
-    }
-
-    public static boolean isLabeledExpression(JetPrefixExpression expression) {
-        return expression.getOperationReference().getReferencedNameElementType() == JetTokens.LABEL_IDENTIFIER;
-    }
-
-    @NotNull
-    public static String getLabelName(@NotNull JetPrefixExpression expression) {
-        assert isLabeledExpression(expression);
-        String labelName = expression.getOperationReference().getReferencedName();
-        assert labelName.startsWith("@") : "Incorrect label name " + expression.getText();
-        return labelName.substring(1);
-    }
-
     @NotNull
     public static Name safeName(@Nullable String name) {
         return name == null ? SpecialNames.NO_NAME_PROVIDED : Name.identifier(name);
@@ -571,7 +551,7 @@ public class JetPsiUtil {
             return maxPriority - 1;
         }
 
-        if (expression instanceof JetPrefixExpression) return maxPriority - 2;
+        if (expression instanceof JetPrefixExpression || expression instanceof JetLabeledExpression) return maxPriority - 2;
 
         if (expression instanceof JetDeclaration || expression instanceof JetStatementExpression || expression instanceof JetIfExpression) {
             return 0;
@@ -625,7 +605,7 @@ public class JetPsiUtil {
         IElementType parentOperation = getOperation(parentExpression);
 
         // 'return (@label{...})' case
-        if (parentExpression instanceof JetReturnExpression && innerOperation == JetTokens.LABEL_IDENTIFIER) {
+        if (parentExpression instanceof JetReturnExpression && innerExpression instanceof JetLabeledExpression) {
             return true;
         }
 

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

@@ -170,6 +170,10 @@ public class JetVisitor<R, D> extends PsiElementVisitor {
         return visitExpression(expression, data);
     }
 
+    public R visitLabeledExpression(@NotNull JetLabeledExpression expression, D data) {
+        return visitExpressionWithLabel(expression, data);
+    }
+
     public R visitPrefixExpression(@NotNull JetPrefixExpression expression, D data) {
         return visitUnaryExpression(expression, data);
     }

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

@@ -169,6 +169,10 @@ public class JetVisitorVoid extends JetVisitor<Void, Void> {
         super.visitReferenceExpression(expression, null);
     }
 
+    public void visitLabeledExpression(@NotNull JetLabeledExpression expression) {
+        super.visitLabeledExpression(expression, null);
+    }
+
     public void visitPrefixExpression(@NotNull JetPrefixExpression expression) {
         super.visitPrefixExpression(expression, null);
     }
@@ -630,6 +634,12 @@ public class JetVisitorVoid extends JetVisitor<Void, Void> {
         return null;
     }
 
+    @Override
+    public final Void visitLabeledExpression(@NotNull JetLabeledExpression expression, Void data) {
+        visitLabeledExpression(expression);
+        return null;
+    }
+
     @Override
     public final Void visitPrefixExpression(@NotNull JetPrefixExpression expression, Void data) {
         visitPrefixExpression(expression);

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

@@ -170,6 +170,10 @@ public class JetVisitorVoidWithParameter<P> extends JetVisitor<Void, P> {
         super.visitReferenceExpression(expression, data);
     }
 
+    public void visitLabeledExpressionVoid(@NotNull JetLabeledExpression expression, P data) {
+        super.visitLabeledExpression(expression, data);
+    }
+
     public void visitPrefixExpressionVoid(@NotNull JetPrefixExpression expression, P data) {
         super.visitPrefixExpression(expression, data);
     }
@@ -627,6 +631,12 @@ public class JetVisitorVoidWithParameter<P> extends JetVisitor<Void, P> {
     	return null;
     }
 
+    @Override
+    public final Void visitLabeledExpression(@NotNull JetLabeledExpression expression, P data) {
+        visitLabeledExpressionVoid(expression, data);
+        return null;
+    }
+
     @Override
     public final Void visitPrefixExpression(@NotNull JetPrefixExpression expression, P data) {
         visitPrefixExpressionVoid(expression, data);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java

@@ -492,8 +492,8 @@ public class CandidateResolver {
             }
 
             @Override
-            public JetExpression visitPrefixExpression(@NotNull JetPrefixExpression expression, Void data) {
+            public JetExpression visitLabeledExpression(@NotNull JetLabeledExpression expression, Void data) {
-                return visitInnerExpression(JetPsiUtil.getBaseExpressionIfLabeledExpression(expression));
+                return visitInnerExpression(expression.getBaseExpression());
             }
 
             @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/InlineCallResolverExtension.java

@@ -105,17 +105,16 @@ public class InlineCallResolverExtension implements CallResolverExtension {
             if (parent instanceof JetValueArgument ||
                 parent instanceof JetBinaryExpression ||
                 parent instanceof JetUnaryExpression ||
+                parent instanceof JetLabeledExpression ||
                 parent instanceof JetDotQualifiedExpression ||
                 parent instanceof JetCallExpression ||
                 parent instanceof JetArrayAccessExpression ||
                 parent instanceof JetMultiDeclaration) {
 
-                if (parent instanceof JetPrefixExpression) {
+                if (parent instanceof JetLabeledExpression) {
-                    if (JetPsiUtil.isLabeledExpression((JetPrefixExpression) parent)) {
                     parent = parent.getParent();
                     continue;
                 }
-                }
                 else if (parent instanceof JetBinaryExpression) {
                     JetToken token = JetPsiUtil.getOperationToken((JetOperationExpression) parent);
                     if (token == JetTokens.EQ || token == JetTokens.ANDAND || token == JetTokens.OROR) {

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

@@ -601,11 +601,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     }
 
     @Override
-    public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
-        return visitUnaryExpression(expression, context, false);
-    }
-
-    public JetTypeInfo visitUnaryExpression(JetUnaryExpression expression, ExpressionTypingContext contextWithExpectedType, boolean isStatement) {
         ExpressionTypingContext context = isUnaryExpressionDependentOnExpectedType(expression)
                 ? contextWithExpectedType
                 : contextWithExpectedType.replaceContextDependency(INDEPENDENT).replaceExpectedType(NO_EXPECTED_TYPE);
@@ -616,10 +612,6 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         JetSimpleNameExpression operationSign = expression.getOperationReference();
 
         IElementType operationType = operationSign.getReferencedNameElementType();
-        // If it's a labeled expression
-        if (operationType == JetTokens.LABEL_IDENTIFIER) {
-            return visitLabeledExpression(expression, context, isStatement);
-        }
 
         // Special case for expr!!
         if (operationType == JetTokens.EXCLEXCL) {
@@ -741,12 +733,21 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         return JetTypeInfo.create(TypeUtils.makeNotNullable(baseType), dataFlowInfo);
     }
 
-    private JetTypeInfo visitLabeledExpression(@NotNull JetUnaryExpression expression, @NotNull ExpressionTypingContext context,
+    @Override
-            boolean isStatement) {
+    public JetTypeInfo visitLabeledExpression(
+            @NotNull JetLabeledExpression expression, ExpressionTypingContext context
+    ) {
+        return visitLabeledExpression(expression, context, false);
+    }
+
+    @NotNull
+    public JetTypeInfo visitLabeledExpression(
+            @NotNull JetLabeledExpression expression,
+            @NotNull ExpressionTypingContext context,
+            boolean isStatement
+    ) {
         JetExpression baseExpression = expression.getBaseExpression();
-        assert baseExpression != null;
+        if (baseExpression == null) return JetTypeInfo.create(null, context.dataFlowInfo);
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
-        assert operationSign.getReferencedNameElementType() == JetTokens.LABEL_IDENTIFIER;
 
         return facade.getTypeInfo(baseExpression, context, isStatement);
     }

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

@@ -484,7 +484,6 @@ public class ExpressionTypingUtils {
     }
 
     public static boolean isUnaryExpressionDependentOnExpectedType(@NotNull JetUnaryExpression expression) {
-        IElementType operationType = expression.getOperationReference().getReferencedNameElementType();
+        return expression.getOperationReference().getReferencedNameElementType() == JetTokens.EXCLEXCL;
-        return operationType == JetTokens.LABEL_IDENTIFIER || operationType == JetTokens.EXCLEXCL;
     }
 }

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

@@ -385,7 +385,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     }
 
     @Override
-    public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext context) {
+    public JetTypeInfo visitLabeledExpression(@NotNull JetLabeledExpression expression, ExpressionTypingContext context) {
-        return basic.visitUnaryExpression(expression, context, true);
+        return basic.visitLabeledExpression(expression, context, true);
     }
 }

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

@@ -59,13 +59,10 @@ public class LabelResolver {
 
     @Nullable
     private Name getLabelNameIfAny(@NotNull PsiElement element) {
-        if (element instanceof JetPrefixExpression) {
+        if (element instanceof JetLabeledExpression) {
-            JetPrefixExpression prefixExpression = (JetPrefixExpression) element;
+            return Name.identifierForLabel(((JetLabeledExpression) element).getLabelName());
-            if (JetPsiUtil.isLabeledExpression(prefixExpression)) {
-                return Name.identifierForLabel(JetPsiUtil.getLabelName(prefixExpression));
         }
-        }
+        if (element instanceof JetFunctionLiteralExpression) {
-        else if (element instanceof JetFunctionLiteralExpression) {
             return getCallerName((JetFunctionLiteralExpression) element);
         }
         return null;

idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java

@@ -267,7 +267,7 @@ public class JetPositionManager implements PositionManager {
         PsiElement valueArgument = functionLiteralExpression;
         while (parent instanceof JetParenthesizedExpression ||
                parent instanceof JetBinaryExpressionWithTypeRHS ||
-               parent instanceof JetPrefixExpression && JetPsiUtil.isLabeledExpression((JetPrefixExpression) parent)) {
+               parent instanceof JetLabeledExpression) {
             valueArgument = parent;
             parent = parent.getParent();
         }

idea/src/org/jetbrains/jet/plugin/highlighter/LabelsHighlightingVisitor.java

@@ -19,23 +19,13 @@ package org.jetbrains.jet.plugin.highlighter;
 import com.intellij.lang.annotation.AnnotationHolder;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetExpressionWithLabel;
-import org.jetbrains.jet.lang.psi.JetPrefixExpression;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
-import org.jetbrains.jet.lexer.JetTokens;
 
 class LabelsHighlightingVisitor extends HighlightingVisitor {
     LabelsHighlightingVisitor(AnnotationHolder holder) {
         super(holder);
     }
 
-    @Override
-    public void visitPrefixExpression(@NotNull JetPrefixExpression expression) {
-        JetSimpleNameExpression operationSign = expression.getOperationReference();
-        if (operationSign.getReferencedNameElementType() == JetTokens.LABEL_IDENTIFIER) {
-            JetPsiChecker.highlightName(holder, operationSign, JetHighlightingColors.LABEL);
-        }
-    }
-
     @Override
     public void visitExpressionWithLabel(@NotNull JetExpressionWithLabel expression) {
         JetSimpleNameExpression targetLabel = expression.getTargetLabel();

idea/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java

@@ -86,8 +86,8 @@ class JetInvokeFunctionReference extends JetSimpleReference<JetCallExpression> i
 
         List<JetExpression> functionLiteralArguments = getExpression().getFunctionLiteralArguments();
         for (JetExpression functionLiteralArgument : functionLiteralArguments) {
-            while (functionLiteralArgument instanceof JetPrefixExpression) {
+            while (functionLiteralArgument instanceof JetLabeledExpression) {
-                functionLiteralArgument = ((JetPrefixExpression) functionLiteralArgument).getBaseExpression();
+                functionLiteralArgument = ((JetLabeledExpression) functionLiteralArgument).getBaseExpression();
             }
 
             if (functionLiteralArgument instanceof JetFunctionLiteralExpression) {

idea/src/org/jetbrains/jet/plugin/util/JetPsiPrecedences.kt

@@ -46,6 +46,7 @@ public object JetPsiPrecedences {
     public fun getPrecedence(expression: JetExpression): Int {
         return when (expression) {
             is JetAnnotatedExpression,
+            is JetLabeledExpression,
             is JetPrefixExpression -> PRECEDENCE_OF_PREFIX_EXPRESSION
             is JetPostfixExpression -> PRECEDENCE_OF_POSTFIX_EXPRESSION
             is JetOperationExpression -> {

js/js.translator/src/org/jetbrains/k2js/translate/expression/ExpressionVisitor.java

@@ -291,25 +291,23 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
         return QualifiedExpressionTranslator.translateQualifiedExpression(expression, context);
     }
 
+    @Override
+    public JsNode visitLabeledExpression(
+            @NotNull JetLabeledExpression expression, TranslationContext context
+    ) {
+        JetExpression baseExpression = expression.getBaseExpression();
+        assert baseExpression != null;
+        return new JsLabel(context.scope().declareName(getReferencedName(expression.getTargetLabel())),
+                             convertToStatement(baseExpression.accept(this, context))).source(expression);
+    }
+
     @Override
     @NotNull
     public JsNode visitPrefixExpression(
             @NotNull JetPrefixExpression expression,
             @NotNull TranslationContext context
     ) {
-        JetSimpleNameExpression operationReference = expression.getOperationReference();
+        return UnaryOperationTranslator.translate(expression, context).source(expression);
-        IElementType operationToken = operationReference.getReferencedNameElementType();
-        JsNode result;
-        if (operationToken == JetTokens.LABEL_IDENTIFIER) {
-            JetExpression baseExpression = expression.getBaseExpression();
-            assert baseExpression != null;
-            result = new JsLabel(context.scope().declareName(getReferencedName(operationReference)),
-                                        convertToStatement(baseExpression.accept(this, context)));
-        }
-        else {
-            result = UnaryOperationTranslator.translate(expression, context);
-        }
-        return result.source(expression);
     }
 
     @Override