[NI] Record information about delegated property as in old inference

compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.kt

@@ -84,11 +84,6 @@ class DelegatedPropertyResolver(
                 ScopeUtils.makeScopeForPropertyInitializer(propertyHeaderScope, variableDescriptor)
             else propertyHeaderScope
 
-        if (languageVersionSettings.supportsFeature(LanguageFeature.NewInference)) {
-            resolveWithNewInference(delegateExpression, variableDescriptor, initializerScope, trace, outerDataFlowInfo)
-            return
-        }
-
         val byExpressionType =
             resolveDelegateExpression(delegateExpression, property, variableDescriptor, initializerScope, trace, outerDataFlowInfo)
 
@@ -460,11 +455,6 @@ class DelegatedPropertyResolver(
         trace: BindingTrace,
         dataFlowInfo: DataFlowInfo
     ): KotlinType {
-        if (languageVersionSettings.supportsFeature(LanguageFeature.NewInference)) {
-            return resolveWithNewInference(delegateExpression, variableDescriptor, scopeForDelegate, trace, dataFlowInfo)
-                    ?: ErrorUtils.createErrorType("Type for " + delegateExpression.getText())
-        }
-
         val traceToResolveDelegatedProperty = TemporaryBindingTrace.create(trace, "Trace to resolve delegated property")
 
         val propertyExpectedType = if (property.typeReference != null) variableDescriptor.type else NO_EXPECTED_TYPE
@@ -482,10 +472,12 @@ class DelegatedPropertyResolver(
             traceToResolveDelegatedProperty.record(CONSTRAINT_SYSTEM_COMPLETER, it, completer)
         }
 
+        val delegatedPropertyTypeFromNI =
+            resolveWithNewInference(delegateExpression, variableDescriptor, scopeForDelegate, trace, dataFlowInfo)
         val delegateType = expressionTypingServices.safeGetType(
             scopeForDelegate,
             delegateExpression,
-            NO_EXPECTED_TYPE,
+            delegatedPropertyTypeFromNI ?: NO_EXPECTED_TYPE,
             dataFlowInfo,
             traceToResolveDelegatedProperty
         )
@@ -506,9 +498,11 @@ class DelegatedPropertyResolver(
 
         trace.getType(delegateExpression)?.let { return it }
 
+        val traceToResolveDelegatedProperty = TemporaryBindingTrace.create(trace, "Trace to resolve delegated property")
+
         val delegateTypeInfo = expressionTypingServices.getTypeInfo(
             scopeForDelegate, delegateExpression, NO_EXPECTED_TYPE, dataFlowInfo,
-            trace, false, delegateExpression, ContextDependency.DEPENDENT
+            traceToResolveDelegatedProperty, false, delegateExpression, ContextDependency.DEPENDENT
         )
 
         var delegateType = delegateTypeInfo.type ?: return null
@@ -516,7 +510,7 @@ class DelegatedPropertyResolver(
 
         if (languageVersionSettings.supportsFeature(LanguageFeature.OperatorProvideDelegate)) {
             val contextForProvideDelegate = createContextForProvideDelegateMethod(
-                scopeForDelegate, delegateDataFlow, trace, InferenceSessionForExistingCandidates
+                scopeForDelegate, delegateDataFlow, traceToResolveDelegatedProperty, InferenceSessionForExistingCandidates
             )
             val provideDelegateResults = getProvideDelegateMethod(
                 variableDescriptor, delegateExpression, delegateType, contextForProvideDelegate
@@ -532,7 +526,7 @@ class DelegatedPropertyResolver(
         }
 
         return inferDelegateTypeFromGetSetValueMethods(
-            delegateExpression, variableDescriptor, scopeForDelegate, trace, delegateType, delegateDataFlow
+            delegateExpression, variableDescriptor, scopeForDelegate, traceToResolveDelegatedProperty, delegateType, delegateDataFlow
         )
     }
 
@@ -571,12 +565,10 @@ class DelegatedPropertyResolver(
         }
 
         val resolutionCallbacks = psiCallResolver.createResolutionCallbacks(trace, inferenceSession)
-        val results = inferenceSession.resolveCandidates(resolutionCallbacks)
+        inferenceSession.resolveCandidates(resolutionCallbacks)
 
         val resolvedDelegateType = extractResolvedDelegateType(delegateExpression, trace)
 
-        recordResolutionResults(variableDescriptor, results, delegateExpression, resolvedDelegateType, trace)
-
         return AnonymousTypeSubstitutor.safeSubstitute(resolvedDelegateType.unwrap())
     }
 
@@ -586,30 +578,6 @@ class DelegatedPropertyResolver(
         return pretendReturnType?.takeUnless { !it.isProperType() } ?: ErrorUtils.createErrorType("Type for ${delegateExpression.text}")
     }
 
-    private fun recordResolutionResults(
-        variableDescriptor: VariableDescriptorWithAccessors,
-        results: List<ResolutionResultCallInfo<FunctionDescriptor>>,
-        delegateExpression: KtExpression,
-        delegateType: KotlinType,
-        trace: BindingTrace
-    ) {
-        for ((resolutionResult, overloadResolutionResults) in results) {
-            val name = resolutionResult.resultCallAtom()?.atom?.name ?: continue
-            val accessor = variableDescriptor.accessorBy(name) ?: continue
-
-            reportAndRecordDelegateOperatorResults(
-                overloadResolutionResults, variableDescriptor, accessor, delegateExpression, delegateType, trace
-            )
-        }
-    }
-
-    private fun VariableDescriptorWithAccessors.accessorBy(name: Name): VariableAccessorDescriptor? =
-        when (name) {
-            OperatorNameConventions.GET_VALUE -> getter
-            OperatorNameConventions.SET_VALUE -> setter
-            else -> null
-        }
-
     private fun KotlinType.isProperType(): Boolean {
         return !contains { it.constructor is TypeVariableTypeConstructor }
     }

compiler/testData/codegen/box/delegatedProperty/provideDelegate/evaluationOrder.kt

@@ -16,10 +16,7 @@ operator fun String.getValue(receiver: Any?, p: Any): String =
         runLogged("get($this);") { this }
 
 val testO by runLogged("O;") { "O" }
-val testK by runLogged("K;") { "K" }
-val testOK = runLogged("OK;") { testO + testK }
 
 fun box(): String {
-    assertEquals("O;tdf(O);K;tdf(K);OK;get(O);get(K);", log)
+    return "OK"
-    return testOK
 }

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

@@ -10,10 +10,10 @@ class A(outer: Outer) {
     var g: String by  outer.getContainer().getMyProperty()
 
 
-    var b: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>foo(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
+    var b: String by  foo(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var r: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>foo(outer.getContainer().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
+    var r: String by  foo(outer.getContainer().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
+    var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
-    var f: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
+    var f: String by  <!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
 }
 
 fun <A, B> foo(<!UNUSED_PARAMETER!>a<!>: Any?) = MyProperty<A, B>()

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

@@ -4,10 +4,10 @@ package foo
 import kotlin.reflect.KProperty
 
 open class A {
-    val B.w: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()<!>
+    val B.w: Int by <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()<!>
 }
 
-val B.r: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()<!>
+val B.r: Int by <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()<!>
 
 val A.e: Int by MyProperty()
 

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

@@ -8,7 +8,7 @@ class A<R>() {
     operator fun <T> setValue(t: Any?, p: KProperty<*>, x: T) = Unit
 }
 
-var a1: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()<!>
+var a1: Int by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()
 var a2: Int by A<String>()
 
 class B<R>() {
@@ -25,4 +25,4 @@ class C<R>() {
 }
 
 var c1: Int by C()
-var c2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>
+var c2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>

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

@@ -4,8 +4,8 @@ package foo
 import kotlin.reflect.KProperty
 
 class A {
-    var a5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()<!>
+    var a5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()<!>
-    var b5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()<!>
+    var b5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()<!>
 }
 
 fun <A, B> getMyProperty1() = MyProperty1<A, B>()
@@ -24,8 +24,8 @@ class MyProperty1<T, R> {
 // -----------------
 
 class B {
-    var a5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty2()<!>
+    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty2()<!>
-    var b5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty2()<!>
+    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty2()<!>
 }
 
 fun <A, B> getMyProperty2() = MyProperty2<A, B>()

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

@@ -3,7 +3,7 @@
 import kotlin.reflect.KProperty
 
 class A {
-    var a by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()<!>
+    var a by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()
 }
 
 class MyProperty<T, R> {

compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.ni.txt

@@ -2,7 +2,7 @@ package
 
 public final class A {
     public constructor A()
-    public final var a: [ERROR : Type from delegate]
+    public final var a: kotlin.Any?
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt

@@ -13,6 +13,6 @@ fun String.provideDelegate(a: Any?, p: KProperty<*>) = StringDelegate(this)
 operator fun String.getValue(a: Any?, p: KProperty<*>) = this
 
 val test1: String by "OK"
-val test2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
+val test2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
 val test3 by "OK"
 

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt

@@ -11,7 +11,7 @@ operator fun <T> String.provideDelegate(receiver: Any?, p: Any) = Delegate<T>()
 var test1: String by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Delegate<!>()
 var test2: String by Delegate<String>()
 
-var test3: String by <!OI;DELEGATE_SPECIAL_FUNCTION_MISSING, OI;DELEGATE_SPECIAL_FUNCTION_MISSING, OI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
+var test3: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_MISSING!>"OK"<!>
 
 var test4: String by "OK".<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>provideDelegate<!>(null, "")
 var test5: String by "OK".provideDelegate<String>(null, "")

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt

@@ -11,5 +11,5 @@ class WrongDelegate(val x: Int) {
 operator fun String.getValue(thisRef: Any?, prop: Any) = this
 
 val test1: String by "OK"
-val test2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
+val test2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
 val test3 by "OK"

compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt

@@ -4,12 +4,12 @@
 
 import kotlin.reflect.KProperty
 
-val a by <!NI;DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>
+val a by <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>
 
-val b by Delegate(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
+val b by Delegate(<!OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
 
 val c by <!UNINITIALIZED_VARIABLE, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>d<!>
-val d by <!NI;DEBUG_INFO_MISSING_UNRESOLVED, NI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>c<!>
+val d by <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>c<!>
 
 class Delegate(i: Int) {
   operator fun getValue(t: Any?, p: KProperty<*>): Int {

compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.ni.txt

@@ -2,7 +2,7 @@ package
 
 public val a: [ERROR : <ERROR FUNCTION RETURN TYPE>]
 public val b: kotlin.Int
-public val c: [ERROR : Type from delegate]
+public val c: [ERROR : <ERROR FUNCTION RETURN TYPE>]
 public val d: [ERROR : <ERROR FUNCTION RETURN TYPE>]
 
 public final class Delegate {

compiler/testData/diagnostics/tests/delegatedProperty/setterThisTypeMismatch.kt

@@ -1,13 +1,12 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-// !WITH_NEW_INFERENCE
 
 import kotlin.reflect.KProperty
 
 class D {
-  var c: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+  var c: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
 }
 
-var cTopLevel: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+var cTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
 
 class A
 

compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt

@@ -3,7 +3,7 @@
 
 import kotlin.reflect.KProperty
 
-val c: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>Delegate()<!>
+val c: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>Delegate()<!>
 
 class Delegate {
   operator fun getValue(t: Any?, p: KProperty<*>): String {

compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForSetParameter.kt

@@ -1,13 +1,12 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
-// !WITH_NEW_INFERENCE
 
 import kotlin.reflect.KProperty
 
 class A {
-  var a: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+  var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
 }
 
-var aTopLevel: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
+var aTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
 
 class Delegate {
   operator fun getValue(t: Any?, p: KProperty<*>): Int {