Pseudocode: Drop CompilationErrorInstruction

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

@@ -157,8 +157,6 @@ public interface JetControlFlowBuilder {
             @NotNull List<PseudoValue> inputValues
     );
 
-    void compilationError(@NotNull JetElement element, @NotNull String message);
-
     void write(
             @NotNull JetElement assignment,
             @NotNull JetElement lValue,

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

@@ -114,11 +114,6 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil
         return getDelegateBuilder().predefinedOperation(expression, operation, inputValues);
     }
 
-    @Override
-    public void compilationError(@NotNull JetElement element, @NotNull String message) {
-        getDelegateBuilder().compilationError(element, message);
-    }
-
     @Override
     @NotNull
     public Label createUnboundLabel() {

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

@@ -457,7 +457,8 @@ public class JetControlFlowProcessor {
         ) {
             JetExpression left = JetPsiUtil.deparenthesize(lhs);
             if (left == null) {
-                builder.compilationError(lhs, "No lValue in assignment");
+                List<PseudoValue> arguments = Collections.singletonList(rhsDeferredValue.invoke());
+                builder.magic(parentExpression, parentExpression, arguments, defaultTypeMap(arguments), MagicKind.UNSUPPORTED_ELEMENT);
                 return;
             }
 
@@ -576,7 +577,7 @@ public class JetControlFlowProcessor {
         private void generateArrayAccess(JetArrayAccessExpression arrayAccessExpression, @Nullable ResolvedCall<?> resolvedCall) {
             if (builder.getBoundValue(arrayAccessExpression) != null) return;
             mark(arrayAccessExpression);
-            if (!checkAndGenerateCall(arrayAccessExpression, resolvedCall)) {
+            if (!checkAndGenerateCall(resolvedCall)) {
                 generateArrayAccessWithoutCall(arrayAccessExpression);
             }
         }
@@ -1480,14 +1481,11 @@ public class JetControlFlowProcessor {
 
         private boolean generateCall(@Nullable JetElement callElement) {
             if (callElement == null) return false;
-            return checkAndGenerateCall(callElement, getResolvedCall(callElement, trace.getBindingContext()));
+            return checkAndGenerateCall(getResolvedCall(callElement, trace.getBindingContext()));
         }
 
-        private boolean checkAndGenerateCall(@NotNull JetElement callElement, @Nullable ResolvedCall<?> resolvedCall) {
+        private boolean checkAndGenerateCall(@Nullable ResolvedCall<?> resolvedCall) {
-            if (resolvedCall == null) {
+            if (resolvedCall == null) return false;
-                builder.compilationError(callElement, "No resolved call");
-                return false;
-            }
             generateCall(resolvedCall);
             return true;
         }

compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java

@@ -530,11 +530,6 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
             }
         }
 
-        @Override
-        public void compilationError(@NotNull JetElement element, @NotNull String message) {
-            add(new CompilationErrorInstruction(element, getCurrentScope(), message));
-        }
-
         @NotNull
         private ReadValueInstruction read(
                 @NotNull JetExpression expression,

compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/InstructionVisitor.kt

@@ -105,10 +105,6 @@ public open class InstructionVisitor() {
         visitOperation(instruction)
     }
 
-    public open fun visitCompilationErrorInstruction(instruction: CompilationErrorInstruction) {
-        visitInstructionWithNext(instruction)
-    }
-
     public open fun visitMarkInstruction(instruction: MarkInstruction) {
         visitInstructionWithNext(instruction)
     }

compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/InstructionVisitorWithResult.kt

@@ -104,10 +104,6 @@ public abstract class InstructionVisitorWithResult<R>() {
         return visitOperation(instruction)
     }
 
-    public open fun visitCompilationErrorInstruction(instruction: CompilationErrorInstruction): R {
-        return visitInstructionWithNext(instruction)
-    }
-
     public open fun visitMarkInstruction(instruction: MarkInstruction): R {
         return visitInstructionWithNext(instruction)
     }

compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/special/CompilationErrorInstruction.kt

@@ -1,42 +0,0 @@
-/*
- * Copyright 2010-2014 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.cfg.pseudocode.instructions.special
-
-import org.jetbrains.jet.lang.psi.JetElement
-import org.jetbrains.jet.lang.cfg.pseudocode.instructions.LexicalScope
-import org.jetbrains.jet.lang.cfg.pseudocode.instructions.InstructionWithNext
-import org.jetbrains.jet.lang.cfg.pseudocode.instructions.InstructionVisitor
-import org.jetbrains.jet.lang.cfg.pseudocode.instructions.InstructionVisitorWithResult
-
-public class CompilationErrorInstruction(
-        element: JetElement,
-        lexicalScope: LexicalScope,
-        val message: String
-) : InstructionWithNext(element, lexicalScope) {
-
-    override fun accept(visitor: InstructionVisitor) {
-        visitor.visitCompilationErrorInstruction(this)
-    }
-
-    override fun <R> accept(visitor: InstructionVisitorWithResult<R>): R {
-        return visitor.visitCompilationErrorInstruction(this)
-    }
-
-    override fun createCopy() = CompilationErrorInstruction(element, lexicalScope, message)
-
-    override fun toString() = "error(${render(element)}, $message)"
-}

compiler/testData/cfg-variables/bugs/varInitializationInIf.instructions

@@ -29,10 +29,8 @@ L2 [else branch]:
     r(true) -> <v5>                                                                                               USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
     w(b|<v5>)                                                                     INIT: in: {b=D} out: {b=ID}     USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
 L3 ['if' expression result]:
-  2 merge(if (1 < 2) { b = false } else { b = true }|!<v4>, !<v6>) -> <v7>        INIT: in: {b=ID} out: {b=ID}
+  2 merge(if (1 < 2) { b = false } else { b = true }|!<v4>, !<v6>) -> <v7>        INIT: in: {b=ID} out: {b=ID}    USE: in: {b=READ} out: {b=READ}
-    error(use(b), No resolved call)                                                                               USE: in: {b=READ} out: {b=READ}
     r(b) -> <v8>                                                                                                  USE: in: {} out: {b=READ}
-    error(use, No resolved call)
     mark(use(b))
     magic[UNRESOLVED_CALL](use(b)|<v8>, !<v9>) -> <v10>
 L1:
@@ -41,4 +39,4 @@ error:
     <ERROR>
 sink:
     <SINK>                                                                                                        USE: in: {} out: {}
-=====================
+=====================

compiler/testData/cfg/arrays/arrayIncUnresolved.instructions

@@ -22,7 +22,6 @@ L0:
     w(a|<v0>)
   2 mark({ a[0]++ })
     mark(a[0])
-    error(a[0], No resolved call)
     r(a) -> <v1>
     r(0) -> <v2>
     magic[UNRESOLVED_CALL](a[0]|<v1>, <v2>) -> <v3>

compiler/testData/cfg/arrays/arraySetPlusAssignUnresolved.instructions

@@ -22,7 +22,6 @@ L0:
     w(a|<v0>)
   2 mark({ a[0] += 1 })
     mark(a[0])
-    error(a[0], No resolved call)
     r(a) -> <v1>
     r(0) -> <v2>
     magic[UNRESOLVED_CALL](a[0]|<v1>, <v2>) -> <v3>

compiler/testData/cfg/arrays/arraySetUnresolved.instructions

@@ -22,7 +22,6 @@ L0:
     w(a|<v0>)
   2 mark({ a[1] = 2 })
     mark(a[1])
-    error(a[1], No resolved call)
     r(a) -> <v1>
     r(1) -> <v2>
     magic[UNRESOLVED_CALL](a[1]|<v1>, <v2>) -> <v3>

compiler/testData/cfg/declarations/functions/typeParameter.instructions

@@ -6,7 +6,6 @@ fun <T> foo() {
 L0:
   1 <START>
   2 mark({ T })
-    error(T, No resolved call)
     magic[UNRESOLVED_CALL](T) -> <v0>
 L1:
   1 <END>                                NEXT:[<SINK>]
@@ -14,4 +13,4 @@ error:
     <ERROR>                              PREV:[]
 sink:
     <SINK>                               PREV:[<ERROR>, <END>]
-=====================
+=====================

compiler/testData/cfg/expressions/chainedQualifiedExpression.instructions

@@ -212,7 +212,6 @@ L0:
     mark(add(OUT_KEYWORD, inTopLevel))
     call(add(OUT_KEYWORD, inTopLevel), add|<v99>, <v100>, <v101>) -> <v102>
     r(OBJECT_KEYWORD) -> <v103>
-    error(unresolvedCode, No resolved call)
     magic[UNRESOLVED_CALL](unresolvedCode) -> <v104>
     mark(add(OBJECT_KEYWORD, unresolvedCode))
     call(add(OBJECT_KEYWORD, unresolvedCode), add|<v102>, <v103>, <v104>) -> <v105>

compiler/testData/cfg/expressions/unresolvedCall.instructions

@@ -10,8 +10,6 @@ L0:
     w(a|<v0>)
   2 mark({ a.foo() })
     mark(a.foo())
-    error(foo(), No resolved call)
-    error(foo, No resolved call)
     r(a) -> <v1>
     mark(foo())
     magic[UNRESOLVED_CALL](foo()|!<v2>, <v1>) -> <v3>
@@ -21,4 +19,4 @@ error:
     <ERROR>                                              PREV:[]
 sink:
     <SINK>                                               PREV:[<ERROR>, <END>]
-=====================
+=====================

compiler/testData/cfg/expressions/unresolvedProperty.instructions

@@ -10,7 +10,6 @@ L0:
     w(a|<v0>)
   2 mark({ a.foo })
     mark(a.foo)
-    error(foo, No resolved call)
     r(a) -> <v1>
     magic[UNRESOLVED_CALL](foo|<v1>) -> <v2>
 L1:
@@ -19,4 +18,4 @@ error:
     <ERROR>                                     PREV:[]
 sink:
     <SINK>                                      PREV:[<ERROR>, <END>]
-=====================
+=====================

compiler/testData/cfg/expressions/unusedExpressionSimpleName.instructions

@@ -9,7 +9,6 @@ L0:
     magic[FAKE_INITIALIZER](arg : Array<String>) -> <v0>
     w(arg|<v0>)
   2 mark({ a })
-    error(a, No resolved call)
     magic[UNRESOLVED_CALL](a) -> <v1>
 L1:
   1 <END>                                                   NEXT:[<SINK>]
@@ -17,4 +16,4 @@ error:
     <ERROR>                                                 PREV:[]
 sink:
     <SINK>                                                  PREV:[<ERROR>, <END>]
-=====================
+=====================