use explicit type of delegated property as expected

while resolving constraint system for delegated expression

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

@@ -0,0 +1,50 @@
+package baz
+
+class A(outer: Outer) {
+    var i: String by  + getMyConcreteProperty()
+    var d: String by  getMyConcreteProperty() - 1
+    var c: String by  O.getMyProperty()
+    var g: String by  outer.getContainer().getMyProperty()
+
+
+    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 f: String by  <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1
+}
+
+fun foo<A, B>(<!UNUSED_PARAMETER!>a<!>: Any?) = MyProperty<A, B>()
+
+fun getMyProperty<A, B>() = MyProperty<A, B>()
+
+fun getMyConcreteProperty() = MyProperty<Any?, String>()
+
+class MyProperty<R, T> {
+
+    public fun get(thisRef: R, desc: PropertyMetadata): T {
+        println("get $thisRef ${desc.name}")
+        return null <!CAST_NEVER_SUCCEEDS!>as<!> T
+    }
+
+    public fun set(thisRef: R, desc: PropertyMetadata, value: T) {
+        println("set $thisRef ${desc.name} $value")
+    }
+}
+
+fun <R, T> MyProperty<R, T>.plus() = MyProperty<R, T>()
+fun <R, T> MyProperty<R, T>.minus(<!UNUSED_PARAMETER!>i<!>: Int) = MyProperty<R, T>()
+
+object O {
+    fun getMyProperty<A, B>() = MyProperty<A, B>()
+}
+
+trait MyPropertyContainer {
+    fun <R, T> getMyProperty(): MyProperty<R, T>
+}
+
+trait Outer {
+    fun getContainer(): MyPropertyContainer
+}
+
+// -----------------
+fun println(a: Any?) = a

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

@@ -0,0 +1,42 @@
+package foo
+
+class A {
+    var a5: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()
+    var b5: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()
+}
+
+fun getMyProperty1<A, B>() = MyProperty1<A, B>()
+
+class MyProperty1<T, R> {
+
+    public fun get(<!UNUSED_PARAMETER!>thisRef<!>: R, <!UNUSED_PARAMETER!>desc<!>: PropertyMetadata): T {
+        throw Exception()
+    }
+
+    public fun set(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>j<!>: Int, <!UNUSED_PARAMETER!>k<!>: Int) {
+        println("set")
+    }
+}
+
+// -----------------
+
+class B {
+    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty2()<!>
+    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty2()<!>
+}
+
+fun getMyProperty2<A, B>() = MyProperty2<A, B>()
+
+class MyProperty2<T, R> {
+
+    public fun get(<!UNUSED_PARAMETER!>thisRef<!>: R, <!UNUSED_PARAMETER!>desc<!>: PropertyMetadata): T {
+        throw Exception()
+    }
+
+    public fun set(<!UNUSED_PARAMETER!>i<!>: Int) {
+        println("set")
+    }
+}
+
+// -----------------
+fun println(a: Any?) = a

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

@@ -0,0 +1,84 @@
+package foo
+
+class A1 {
+    var a1: String by MyProperty1()
+    var b1: String by getMyProperty1()
+}
+
+var c1: String by getMyProperty1<Nothing?, String>()
+
+fun getMyProperty1<A, B>() = MyProperty1<A, B>()
+
+class MyProperty1<R, T> {
+
+    public fun get(thisRef: R, desc: PropertyMetadata): T {
+        println("get $thisRef ${desc.name}")
+        throw Exception()
+    }
+
+    public fun set(thisRef: R, desc: PropertyMetadata, value: T) {
+        println("set $thisRef ${desc.name} $value")
+    }
+}
+
+//--------------------------
+
+class A2 {
+    var a2: String by MyProperty2()
+    var b2: String by getMyProperty2()
+}
+
+fun getMyProperty2<A>() = MyProperty2<A>()
+
+class MyProperty2<T> {
+
+    public fun get(thisRef: Any?, desc: PropertyMetadata): T {
+        println("get $thisRef ${desc.name}")
+        throw Exception()
+    }
+
+    public fun set(thisRef: Any?, desc: PropertyMetadata, value: T) {
+        println("set $thisRef ${desc.name} $value")
+    }
+}
+
+//--------------------------
+
+class A3 {
+    var a3: String by MyProperty3()
+    var b3: String by getMyProperty3()
+}
+
+fun getMyProperty3<A>() = MyProperty3<A>()
+
+class MyProperty3<T> {
+
+    public fun get(thisRef: T, desc: PropertyMetadata): String {
+        println("get $thisRef ${desc.name}")
+        return ""
+    }
+
+    public fun set(thisRef: Any?, desc: PropertyMetadata, value: T) {
+        println("set $thisRef ${desc.name} $value")
+    }
+}
+
+//--------------------------
+
+class A4 {
+    val a4: String by MyProperty4()
+    val b4: String by getMyProperty4()
+}
+
+fun getMyProperty4<A, B>() = MyProperty4<A, B>()
+
+class MyProperty4<R, T> {
+
+    public fun get(thisRef: R, desc: PropertyMetadata): T {
+        println("get $thisRef ${desc.name}")
+        throw Exception()
+    }
+}
+
+//--------------------------
+fun println(a: Any?) = a