FIR: Fix test data for secondary constructor delegation calls

They appeared, after the changes in previous commits at
org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer#transformDelegatedConstructorCall

The idea is that dispatch receiver is available there in old FE, but additional
diagnostic should be reported on it (see KT-38813)

This change was not made intentionaly but it was the easiest way to
support new tower data elements structure and on the other side it's the
correct behavior as for old FE.

Also, if we once would prefer the previous behavior it's still not very
hard to support it

compiler/testData/diagnostics/tests/scopes/classHeader/constructors.fir.kt

@@ -37,8 +37,8 @@ class A(
         Companion.CONST,
         Nested.CONST,
         Interface.CONST,
-        <!UNRESOLVED_REFERENCE!>a<!>,
-        <!UNRESOLVED_REFERENCE!>b<!>()
+        a,
+        b()
     )
 
     class Nested {

compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArgumentsInSecondaryConstructor.fir.kt

@@ -22,8 +22,8 @@ class A : S {
             Companion.CONST,
             Nested.CONST,
             Interface.CONST,
-            <!UNRESOLVED_REFERENCE!>a<!>,
-            <!UNRESOLVED_REFERENCE!>b<!>()
+            a,
+            b()
     )
 
     class Nested {

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.fir.kt

@@ -6,7 +6,7 @@ open class Base<T>(p: Any?) {
 
 class D: Base<Int>("") {
     inner class B : Base<String> {
-        constructor() : super(<!INAPPLICABLE_CANDIDATE!>foo1<!>(""))
+        constructor() : super(foo1(""))
         constructor(x: Int) : super(foo1(1))
     }
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase2.fir.kt

@@ -7,7 +7,7 @@ open class Base<T>(p: Any?) {
 class D: Base<Int>(1) {
     inner class B : Base<Int> {
         constructor() : super(foo1(1))
-        constructor(x: Int) : super(this@B.<!UNRESOLVED_REFERENCE!>foo1<!>(1))
+        constructor(x: Int) : super(this@B.foo1(1))
         constructor(x: Int, y: Int) : super(this@D.foo1(1))
     }
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseWithSameExtension.fir.kt

@@ -7,6 +7,6 @@ fun Base.foo() {
     class B : Base {
         constructor() : super(foo1())
         constructor(x: Int) : super(this@foo.foo1())
-        constructor(x: Int, y: Int) : super(this@B.<!UNRESOLVED_REFERENCE!>foo1<!>())
+        constructor(x: Int, y: Int) : super(this@B.foo1())
     }
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.fir.kt

@@ -5,9 +5,9 @@ open class Base<T>(p: Any?) {
 
 fun Base<Int>.foo() {
     class B : Base<String> {
-        constructor() : super(<!INAPPLICABLE_CANDIDATE!>foo1<!>(""))
+        constructor() : super(foo1(""))
         constructor(x: Int) : super(foo1(1))
         constructor(x: Int, y: Int) : super(this@foo.foo1(12))
-        constructor(x: Int, y: Int, z: Int) : super(this@B.<!UNRESOLVED_REFERENCE!>foo1<!>(""))
+        constructor(x: Int, y: Int, z: Int) : super(this@B.foo1(""))
     }
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/innerInstanceCreation.fir.kt

@@ -7,5 +7,5 @@ class Outer {
 
     constructor(x: Int)
     constructor(x: Int, y: Int, z: Int = x + Inner().prop + this.Inner().prop) :
-        this(x + Inner().prop <!AMBIGUITY!>+<!> this.<!UNRESOLVED_REFERENCE!>Inner<!>().<!UNRESOLVED_REFERENCE!>prop<!>)
+        this(x + Inner().prop + this.Inner().prop)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/lambdaAsArgument.fir.kt

@@ -7,9 +7,9 @@ class A {
     constructor(x: () -> Int)
     constructor() : this(
             {
-                <!UNRESOLVED_REFERENCE!>foo<!>() +
-                this.<!UNRESOLVED_REFERENCE!>foo<!>() +
-                this@A.<!UNRESOLVED_REFERENCE!>foo<!>() +
-                <!UNRESOLVED_REFERENCE!>foobar<!>()
+                foo() +
+                this.foo() +
+                this@A.foo() +
+                foobar()
             })
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt

@@ -3,5 +3,5 @@ class A {
     fun foo() = 1
     constructor(x: Int)
     constructor(x: Int, y: Int, z: Int = x + foo() + this.foo()) :
-        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + this.<!UNRESOLVED_REFERENCE!>foo<!>())
+        this(x + foo() + this.foo())
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsArgument.fir.kt

@@ -6,7 +6,7 @@ class A {
     fun foo() = 1
     constructor(x: Any?)
     constructor() : this(object {
-        fun bar() = <!UNRESOLVED_REFERENCE!>foo<!>() + this@A.<!UNRESOLVED_REFERENCE!>foo<!>() +
-                    <!INAPPLICABLE_CANDIDATE!>foobar<!>() + super@A.<!UNRESOLVED_REFERENCE!>hashCode<!>()
+        fun bar() = foo() + this@A.foo() +
+                    foobar() + super@A.hashCode()
     })
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.fir.kt

@@ -4,8 +4,8 @@ class D : C {
     constructor() : super(
             {
                 val s = ""
-                <!UNRESOLVED_REFERENCE!>s<!>()
-                <!UNRESOLVED_REFERENCE!>""()<!>
+                s()
+                ""()
                 42
             }())
 

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt

@@ -3,5 +3,5 @@ class A {
     val prop = 1
     constructor(x: Int)
     constructor(x: Int, y: Int, z: Int = x + prop + this.prop) :
-        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + this.<!UNRESOLVED_REFERENCE!>prop<!>)
+        this(x + prop + this.prop)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt

@@ -3,5 +3,5 @@ open class B(x: Int)
 class A : B {
     val prop = 1
     constructor(x: Int, y: Int = x + prop + this.prop) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + this.<!UNRESOLVED_REFERENCE!>prop<!>)
+        super(x + prop + this.prop)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt

@@ -4,5 +4,5 @@ open class B(x: Int) {
 }
 class A : B {
     constructor(x: Int, y: Int = x + foo() + this.foo() + super.foo()) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + this.<!UNRESOLVED_REFERENCE!>foo<!>() + super.foo())
+        super(x + foo() + this.foo() + super.foo())
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt

@@ -5,5 +5,5 @@ open class B(x: Int) {
 class A : B {
     override fun foo() = 2
     constructor(x: Int, y: Int = x + foo() + this.foo() + super.foo()) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + this.<!UNRESOLVED_REFERENCE!>foo<!>() + super.foo())
+        super(x + foo() + this.foo() + super.foo())
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt

@@ -2,5 +2,5 @@
 open class B(val prop: Int)
 class A : B {
     constructor(x: Int, y: Int = x + prop + this.prop + super.prop) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + this.<!UNRESOLVED_REFERENCE!>prop<!> + super.prop)
+        super(x + prop + this.prop + super.prop)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.fir.kt

@@ -5,10 +5,10 @@ val A.prop: Int get() = 2
 
 class A {
     constructor(x: Int)
-    constructor() : <!INAPPLICABLE_CANDIDATE!>this<!>(
-            <!UNRESOLVED_REFERENCE!>foobar<!>() +
+    constructor() : this(
+            foobar() +
             this.foobar() +
-            <!UNRESOLVED_REFERENCE!>prop<!> +
+            prop +
             this.prop +
             this@A.prop
     )