[NI] Record all diagnostics from subcalls resolution results

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2017 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.
+ * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.resolve.calls.tower
@@ -65,6 +54,11 @@ class ResolvedAtomCompleter(
             is ResolvedCallableReferenceAtom -> completeCallableReference(resolvedAtom)
             is ResolvedLambdaAtom -> completeLambda(resolvedAtom)
             is ResolvedCallAtom -> completeResolvedCall(resolvedAtom, emptyList())
+            is CallResolutionResult -> {
+                if (resolvedAtom.type == CallResolutionResult.Type.PARTIAL) {
+                    resolvedAtom.resultCallAtom?.let { completeResolvedCall(it, resolvedAtom.diagnostics) }
+                }
+            }
         }
     }
 

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

@@ -34,6 +34,6 @@ val bbb = null ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 val bbbb = ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>) ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 
 fun f(x : Long?): Long {
-    var a = x ?: (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!> <!OI;USELESS_ELVIS!><!NI;USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!><!>)
+    var a = x ?: (<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!> <!OI;USELESS_ELVIS!><!NI;USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!><!>)
     return <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
 }

compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt

@@ -108,7 +108,7 @@ fun testImplicitCoercion() {
     val <!UNUSED_VARIABLE!>h<!> = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
 
     bar(<!NI;TYPE_MISMATCH!>if (true) {
-        <!CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
     }
         else {
         <!UNUSED_VALUE!>z =<!> 342

compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt

@@ -9,8 +9,8 @@ fun test() {
 
     // KT-KT-9070
     <!TYPE_MISMATCH!>{ }<!> <!USELESS_ELVIS!>?: 1<!>
-    use(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{ 2 }<!> <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> 1);
+    use(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{ 2 }<!> <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> 1);
 
     1 <!USELESS_ELVIS!>?: <!TYPE_MISMATCH, UNUSED_LAMBDA_EXPRESSION!>{ }<!><!>
-    use(1 <!USELESS_ELVIS!>?: <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{ }<!><!>)
+    use(1 <!USELESS_ELVIS!>?: <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{ }<!><!>)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt

@@ -6,6 +6,6 @@ fun foo() {
     val x: Int? = null
 
     bar(1 + (if (x == null) 0 else x))
-    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!> else x<!>)
+    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!NI;TYPE_MISMATCH, DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> else x<!>)
     if (x != null) bar(x + x/(x-x*x))
 }

compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt

@@ -14,5 +14,5 @@ fun <A> main() {
     <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>b<!>: Int = f()<!>
     <!NI;UNREACHABLE_CODE!>f<Int>()<!>
 
-    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>с<!>: A = id(<!TYPE_PARAMETER_AS_REIFIED!>f<!>())<!>
+    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>с<!>: A = id(<!NI;TYPE_PARAMETER_AS_REIFIED, TYPE_PARAMETER_AS_REIFIED!>f<!>())<!>
 }

compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt

@@ -0,0 +1,7 @@
+fun <T, U> T.map(f: (T) -> U) = f(this)
+
+fun consume(<!UNUSED_PARAMETER!>s<!>: String) {}
+
+fun test() {
+    consume(1.map(::<!UNRESOLVED_REFERENCE!>foo<!>))
+}

compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.txt

@@ -0,0 +1,5 @@
+package
+
+public fun consume(/*0*/ s: kotlin.String): kotlin.Unit
+public fun test(): kotlin.Unit
+public fun </*0*/ T, /*1*/ U> T.map(/*0*/ f: (T) -> U): U

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt

@@ -15,7 +15,7 @@ fun foo() {
 
     val y: Int? = 0
     val z: Int? = 0
-    bar(<!NI;TYPE_MISMATCH!>if (y != null) y else <!TYPE_MISMATCH!>z<!><!>, <!TYPE_MISMATCH!>y<!>)
+    bar(<!NI;TYPE_MISMATCH!>if (y != null) y else <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>z<!><!>, <!TYPE_MISMATCH!>y<!>)
     y <!UNSAFE_OPERATOR_CALL!>+<!> 2
     baz(<!TYPE_MISMATCH!>y<!>, <!TYPE_MISMATCH!>y<!>, if (y == null) return else y, y)
     baz(y, z!!, z, y)