[NI] Fix substitution for receiver when resolving constructor super call

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
+ * 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.
- * 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.kotlin.resolve.calls.components
@@ -228,12 +217,9 @@ private fun KotlinResolutionCandidate.resolveKotlinArgument(
     isReceiver: Boolean
 ) {
     val expectedType = candidateParameter?.let {
-        resolvedCall.substitutor.substituteKeepAnnotations(
+        val argumentType = argument.getExpectedType(candidateParameter, callComponents.languageVersionSettings)
-            argument.getExpectedType(
+        val resultType = knownTypeParametersResultingSubstitutor?.substitute(argumentType) ?: argumentType
-                candidateParameter,
+        resolvedCall.substitutor.substituteKeepAnnotations(resultType)
-                callComponents.languageVersionSettings
-            )
-        )
     }
     addResolvedKtPrimitive(resolveKtPrimitive(csBuilder, argument, expectedType, this, isReceiver))
 }

compiler/testData/diagnostics/tests/generics/innerClasses/bareTypesComplex.kt

@@ -1,10 +1,9 @@
-// !WITH_NEW_INFERENCE
 open class SuperOuter<E> {
     inner open class SuperInner<F>
 }
 
 class DerivedOuter<G> : SuperOuter<G>() {
-    inner class DerivedInner<H> : SuperOuter<G>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>SuperInner<!><H>()
+    inner class DerivedInner<H> : SuperOuter<G>.SuperInner<H>()
 }
 
 fun bare(x: SuperOuter<*>.SuperInner<*>, y: Any?) {

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/secondLevelDepth.kt

@@ -1,4 +1,3 @@
-// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 open class Outer<E> {
     inner open class Inner<F> {
@@ -9,7 +8,7 @@ open class Outer<E> {
 }
 
 class DerivedOuter : Outer<String>() {
-    inner class DerivedInner : <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>Inner<!><Int>() {
+    inner class DerivedInner : Inner<Int>() {
         fun foo(): Inner2<Char> = null!!
     }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCall.kt

@@ -1,4 +1,3 @@
-// !WITH_NEW_INFERENCE
 open class Super<T> {
     inner open class Inner {
     }
@@ -6,5 +5,5 @@ open class Super<T> {
 
 class Sub : Super<String>() {
     // TODO: it would be nice to have a possibility to omit explicit type argument in supertype
-    inner class SubInner : Super<String>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>Inner<!>() {}
+    inner class SubInner : Super<String>.Inner() {}
 }

compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCallSecondary.kt

@@ -1,4 +1,3 @@
-// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 open class Super<T> {
     inner open class Inner {
@@ -7,7 +6,7 @@ open class Super<T> {
 
 class Sub : Super<String>() {
     inner class SubInner : Super<String>.Inner {
-        constructor()<!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!><!>
+        constructor()
-        constructor(x: Int) : <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>super<!>() {}
+        constructor(x: Int) : super() {}
     }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt

@@ -1,4 +1,3 @@
-// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 open class Super<T> {
@@ -8,7 +7,7 @@ open class Super<T> {
 }
 
 class Sub<T1>(): Super<T1>() {
-    inner class SubInner : Super<T1>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>Inner<!>() { // 'Inner' is unresolved
+    inner class SubInner : Super<T1>.Inner() { // 'Inner' is unresolved
         // Also, T1 is not resolved to anything, and not marked as resolved
         init {
             val x: Super<T1>.Inner = this // T1 is not resolved to anything