Resolve operation (unary, array access) on error element instead of ignoring it

(to record corresponding call for later simplification in control flow)
Generate code for unmapped arguments in control flow

compiler/testData/cfg/functions/unmappedArgs.instructions

@@ -0,0 +1,47 @@
+== foo ==
+fun foo(a: Int, b: Int) = a + b
+---------------------
+L0:
+  1 <START>
+    v(a: Int)
+    magic[FAKE_INITIALIZER](a: Int) -> <v0>
+    w(a|<v0>)
+    v(b: Int)
+    magic[FAKE_INITIALIZER](b: Int) -> <v1>
+    w(b|<v1>)
+    r(a) -> <v2>
+    r(b) -> <v3>
+    mark(a + b)
+    call(a + b, plus|<v2>, <v3>) -> <v4>
+    ret(*|<v4>) L1
+L1:
+    <END>                                      NEXT:[<SINK>]
+error:
+    <ERROR>                                    PREV:[]
+sink:
+    <SINK>                                     PREV:[<ERROR>, <END>]
+=====================
+== bar ==
+fun bar(i: Int) {
+    foo(1, 1, i)
+}
+---------------------
+L0:
+  1 <START>
+    v(i: Int)
+    magic[FAKE_INITIALIZER](i: Int) -> <v0>
+    w(i|<v0>)
+  2 mark({ foo(1, 1, i) })
+    r(1) -> <v1>
+    r(1) -> <v2>
+    r(i) -> <v3>
+    magic[VALUE_CONSUMER](i|<v3>) -> <v4>
+    mark(foo(1, 1, i))
+    call(foo(1, 1, i), foo|<v1>, <v2>) -> <v5>
+L1:
+  1 <END>                                         NEXT:[<SINK>]
+error:
+    <ERROR>                                       PREV:[]
+sink:
+    <SINK>                                        PREV:[<ERROR>, <END>]
+=====================

compiler/testData/cfg/functions/unmappedArgs.kt

@@ -0,0 +1,5 @@
+fun foo(a: Int, b: Int) = a + b
+
+fun bar(i: Int) {
+    foo(1, 1, i)
+}

compiler/testData/cfg/functions/unmappedArgs.values

@@ -0,0 +1,22 @@
+== foo ==
+fun foo(a: Int, b: Int) = a + b
+---------------------
+        <v0>: Int   NEW: magic[FAKE_INITIALIZER](a: Int) -> <v0>
+        <v1>: Int   NEW: magic[FAKE_INITIALIZER](b: Int) -> <v1>
+a       <v2>: Int   NEW: r(a) -> <v2>
+b       <v3>: Int   NEW: r(b) -> <v3>
+a + b   <v4>: Int   NEW: call(a + b, plus|<v2>, <v3>) -> <v4>
+=====================
+== bar ==
+fun bar(i: Int) {
+    foo(1, 1, i)
+}
+---------------------
+                   <v0>: Int   NEW: magic[FAKE_INITIALIZER](i: Int) -> <v0>
+                   <v4>: *     NEW: magic[VALUE_CONSUMER](i|<v3>) -> <v4>
+1                  <v1>: Int   NEW: r(1) -> <v1>
+1                  <v2>: Int   NEW: r(1) -> <v2>
+i                  <v3>: *     NEW: r(i) -> <v3>
+foo(1, 1, i)       <v5>: *     NEW: call(foo(1, 1, i), foo|<v1>, <v2>) -> <v5>
+{ foo(1, 1, i) }   <v5>: *     COPY
+=====================

compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt

@@ -0,0 +1,5 @@
+fun foo(a: Int, b: Int) = a + b
+
+fun bar(i: Int) {
+    foo(1, 1, <!TOO_MANY_ARGUMENTS!>i<!>)
+}

compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt

@@ -9,7 +9,7 @@ class A(outer: Outer) {
 
     var b: String by  foo(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
     var r: String by  foo(outer.getContainer().<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var e: String by  <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
+    var e: String by  <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
     var f: String by  <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1
 }
 

compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt

@@ -1,7 +1,5 @@
 package bar
 
 fun main(args : Array<String>) {
-    <!DEBUG_INFO_MISSING_UNRESOLVED!><!NO_CLASS_OBJECT!>String<!>[<!SYNTAX!><!>]<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>names<!> <!DEBUG_INFO_MISSING_UNRESOLVED!><!SYNTAX!>=<!> ["ads"]<!>
-}
-
-
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!NO_CLASS_OBJECT!>String<!>[<!SYNTAX!><!>]<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>names<!> <!DEBUG_INFO_MISSING_UNRESOLVED!><!SYNTAX!>=<!> ["ads"]<!>
+}

compiler/testData/diagnostics/tests/incompleteCode/kt4866UnresolvedArrayAccess.kt

@@ -1,5 +1,5 @@
 //KT-4866 Resolve does not work inside brackets with unresolved reference before
 
 fun test(i: Int, j: Int) {
-    <!UNRESOLVED_REFERENCE!>foo<!>[i, j]
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!UNRESOLVED_REFERENCE!>foo<!>[i, j]<!>
 }

compiler/testData/diagnostics/tests/incompleteCode/unresolvedOperation.kt

@@ -0,0 +1,4 @@
+fun foo(a: Int) {
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>!<!><!UNRESOLVED_REFERENCE!>bbb<!>
+    <!UNRESOLVED_REFERENCE!>bbb<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> a
+}