FIR: Rename FirSuperTypeScope and reuse it for type parameter type

It would allow ConeKotlinType.scope return FirTypeScope
and thus pulling down org.jetbrains.kotlin.fir.scopes.FirScope#processOverriddenFunctions
(See the following commits)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt

@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.fir.java.scopes.JavaClassEnhancementScope
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassUseSiteMemberScope
 import org.jetbrains.kotlin.fir.java.scopes.JavaOverrideChecker
 import org.jetbrains.kotlin.fir.resolve.*
-import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -89,7 +89,7 @@ class JavaScopeProvider(
                     }
             JavaClassUseSiteMemberScope(
                 regularClass, useSiteSession,
-                FirSuperTypeScope.prepareOverrideAwareSupertypeScope(
+                FirTypeIntersectionScope.prepareIntersectionScope(
                     useSiteSession,
                     JavaOverrideChecker(
                         useSiteSession,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt

@@ -6,19 +6,20 @@
 package org.jetbrains.kotlin.fir.resolve
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerLiteralTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirStandardOverrideChecker
-import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
+import org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope
 import org.jetbrains.kotlin.fir.scopes.scope
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 
-fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
+fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession): FirTypeScope? {
     return when (this) {
         is ConeKotlinErrorType -> null
         is ConeClassLikeType -> {
@@ -32,7 +33,9 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
         is ConeTypeParameterType -> {
             // TODO: support LibraryTypeParameterSymbol or get rid of it
             val fir = lookupTag.toSymbol().fir
-            FirCompositeScope(
+            FirTypeIntersectionScope.prepareIntersectionScope(
+                useSiteSession,
+                FirStandardOverrideChecker(useSiteSession),
                 fir.bounds.mapNotNullTo(mutableListOf()) {
                     it.coneTypeUnsafe<ConeKotlinType>().scope(useSiteSession, scopeSession)
                 }
@@ -40,7 +43,7 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
         }
         is ConeRawType -> lowerBound.scope(useSiteSession, scopeSession)
         is ConeFlexibleType -> lowerBound.scope(useSiteSession, scopeSession)
-        is ConeIntersectionType -> FirSuperTypeScope.prepareSupertypeScope(
+        is ConeIntersectionType -> FirTypeIntersectionScope.prepareIntersectionScope(
             useSiteSession,
             FirStandardOverrideChecker(useSiteSession),
             intersectedTypes.mapNotNullTo(mutableListOf()) {
@@ -59,7 +62,7 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
                 FirIntegerLiteralTypeScope.SCOPE_SESSION_KEY
             ) {
                 FirIntegerLiteralTypeScope(useSiteSession, isUnsigned)
-            } as FirScope
+            } as FirTypeScope
         }
         else -> null
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt

@@ -61,7 +61,7 @@ class KotlinScopeProvider(
                 }
             FirClassUseSiteMemberScope(
                 useSiteSession,
-                FirSuperTypeScope.prepareOverrideAwareSupertypeScope(
+                FirTypeIntersectionScope.prepareIntersectionScope(
                     useSiteSession, FirStandardOverrideChecker(useSiteSession), scopes
                 ),
                 decoratedDeclaredMemberScope
@@ -100,7 +100,7 @@ internal fun FirClass<*>.scope(
     scopeSession: ScopeSession,
     skipPrivateMembers: Boolean,
     classId: ClassId? = this.classId
-): FirScope {
+): FirTypeScope {
     val basicScope = scopeProvider.getUseSiteMemberScope(
         this, useSiteSession, scopeSession
     )

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerLiteralTypeScope.kt

@@ -5,20 +5,25 @@
 
 package org.jetbrains.kotlin.fir.scopes.impl
 
-import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.resolve.scopeSessionKey
-import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.CallableId
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralType
 import org.jetbrains.kotlin.fir.types.ConeIntegerLiteralTypeImpl
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
@@ -29,7 +34,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 
-class FirIntegerLiteralTypeScope(private val session: FirSession, val isUnsigned: Boolean) : FirScope() {
+class FirIntegerLiteralTypeScope(private val session: FirSession, val isUnsigned: Boolean) : FirTypeScope() {
     sealed class ILTKey {
         object Signed : ILTKey()
         object Unsigned : ILTKey()
@@ -40,7 +45,7 @@ class FirIntegerLiteralTypeScope(private val session: FirSession, val isUnsigned
         val UNARY_OPERATOR_NAMES = FirIntegerOperator.Kind.values().filter { it.unary }.map { it.operatorName }
         private val ALL_OPERATORS = FirIntegerOperator.Kind.values().map { it.operatorName to it }.toMap()
 
-        val SCOPE_SESSION_KEY = scopeSessionKey<ILTKey, FirIntegerLiteralTypeScope>()
+        val SCOPE_SESSION_KEY = scopeSessionKey<ILTKey, FirTypeScope>()
     }
 
     private val BINARY_OPERATOR_SYMBOLS = BINARY_OPERATOR_NAMES.map { name ->
@@ -90,6 +95,11 @@ class FirIntegerLiteralTypeScope(private val session: FirSession, val isUnsigned
 
     override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) {
     }
+
+    override fun processOverriddenFunctions(
+        functionSymbol: FirFunctionSymbol<*>,
+        processor: (FirFunctionSymbol<*>) -> ProcessorAction
+    ): ProcessorAction = ProcessorAction.NEXT
 }
 
 @OptIn(FirImplementationDetail::class)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
-import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.FirOverrideChecker
 import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeFlexibleType
@@ -27,10 +27,10 @@ import org.jetbrains.kotlin.utils.addToStdlib.flattenTo
 import java.util.*
 import kotlin.collections.HashSet
 
-class FirSuperTypeScope private constructor(
+class FirTypeIntersectionScope private constructor(
     session: FirSession,
     overrideChecker: FirOverrideChecker,
-    private val scopes: List<FirScope>,
+    private val scopes: List<FirTypeScope>,
 ) : AbstractFirOverrideScope(session, overrideChecker) {
 
     private val absentFunctions = mutableSetOf<Name>()
@@ -253,22 +253,14 @@ class FirSuperTypeScope private constructor(
     }
 
     companion object {
-        fun prepareSupertypeScope(
+        fun prepareIntersectionScope(
-            session: FirSession,
-            overrideChecker: FirOverrideChecker,
-            scopes: List<FirScope>
-        ): FirScope {
-            scopes.singleOrNull()?.let { return it }
-
-            return FirSuperTypeScope(session, overrideChecker, scopes)
-        }
-
-        // This methods is needed just to preserve the possibility to move
-        // org.jetbrains.kotlin.fir.scopes.FirScope.processOverriddenFunctions to FirOverrideAwareScope
-        fun prepareOverrideAwareSupertypeScope(
             session: FirSession,
             overrideChecker: FirOverrideChecker,
             scopes: List<FirTypeScope>
-        ): FirTypeScope = prepareSupertypeScope(session, overrideChecker, scopes) as FirTypeScope
+        ): FirTypeScope {
+            scopes.singleOrNull()?.let { return it }
+
+            return FirTypeIntersectionScope(session, overrideChecker, scopes)
+        }
     }
 }

compiler/testData/codegen/box/casts/intersectionTypeMultipleBounds.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 interface A {
     fun foo(): Any?
     fun bar(): String
@@ -20,4 +19,4 @@ class C : A, B {
     override fun bar() = "ok"
 }
 
-fun box(): String = bar(C())
+fun box(): String = bar(C())

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/conflictingReturnType.fir.kt

@@ -9,5 +9,5 @@ interface B {
 }
 
 fun <T> test(x: T) where T : B, T : A {
-    x.<!AMBIGUITY!>foo<!>()
+    x.foo()
 }

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/flexibleTypes.fir.kt

@@ -1,19 +0,0 @@
-// !CHECK_TYPE
-// FILE: A.java
-public interface A {
-    String foo();
-}
-
-// FILE: main.kt
-
-interface B {
-    fun foo(): String?
-}
-
-interface C {
-    fun foo(): String
-}
-
-fun <T> test(x: T) where T : B, T : A, T : C {
-    x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
-}

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/flexibleTypes.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // FILE: A.java
 public interface A {

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/mostSpecific.fir.kt

@@ -1,13 +0,0 @@
-// !CHECK_TYPE
-
-interface A {
-    fun foo(): CharSequence?
-}
-
-interface B {
-    fun foo(): String
-}
-
-fun <T> test(x: T) where T : B, T : A {
-    x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
-}

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/mostSpecific.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 interface A {

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/properties.fir.kt

@@ -12,8 +12,8 @@ interface B: A {
 }
 
 fun <T> test(a: T) where T : B, T : C {
-    a.<!AMBIGUITY!>foo<!> = ""
+    a.foo = ""
-    a.<!AMBIGUITY!>foo<!> = null
+    a.foo = null
 
-    a.<!AMBIGUITY!>foo<!>.<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    a.foo.checkType { _<String>() }
 }

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/propertiesConflict.fir.kt

@@ -12,8 +12,8 @@ interface B: A {
 }
 
 fun <T> test(a: T) where T : B, T : C {
-    a.<!AMBIGUITY!>foo<!> = ""
+    a.foo = ""
-    a.<!AMBIGUITY!>foo<!> = null
+    a.foo = null
 
-    a.<!AMBIGUITY!>foo<!>.<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    a.foo.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 }

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/validTypeParameters.fir.kt

@@ -1,13 +0,0 @@
-// !CHECK_TYPE
-
-interface A {
-    fun <T, E> foo(): E
-}
-
-interface B {
-    fun <Q, W> foo(): W
-}
-
-fun <T> test(x: T) where T : B, T : A {
-    x.<!AMBIGUITY!>foo<!><String, Int>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
-}

compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/validTypeParameters.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 interface A {

compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.fir.kt

@@ -22,9 +22,9 @@ fun foo(k: KotlinClass) {
     useString(k.something3)
 
     k.setSomething4("")
-    k.<!UNRESOLVED_REFERENCE, VARIABLE_EXPECTED!>something4<!> += ""
+    k.something4 += ""
     k.<!INAPPLICABLE_CANDIDATE!>setSomething4<!>(null)
-    k.<!UNRESOLVED_REFERENCE!>something4<!> = null
+    k.something4 = null
 
     useString(k.getSomething5())
     useString(k.something5)

compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/12.fir.kt

@@ -3766,31 +3766,31 @@ class Case61_3<T>: InterfaceWithTypeParameter1<T>, Case61_1<T>, Case61_2<T> {
 
 fun <T> T.case_61() where T : InterfaceWithTypeParameter1<T>?, T: Case61_3<T>?, T: Case61_1<T>?, T: Case61_2<T>? {
     if (this != null) {
-        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T!!")!>this<!>.<!AMBIGUITY!>test1<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T!!")!>this<!>.test1()
-        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T!!")!>this<!>.<!AMBIGUITY!>test2<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T!!")!>this<!>.test2()
-        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T!!")!>this<!>.<!AMBIGUITY!>ip1test1<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T!!")!>this<!>.ip1test1()
         <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T!!")!>this<!>.test4()
 
-        <!AMBIGUITY!>test1<!>()
+        test1()
-        <!AMBIGUITY!>test2<!>()
+        test2()
-        <!AMBIGUITY!>ip1test1<!>()
+        ip1test1()
         test4()
         apply {
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>
-            <!AMBIGUITY!>test1<!>()
+            test1()
-            <!AMBIGUITY!>test2<!>()
+            test2()
-            <!AMBIGUITY!>ip1test1<!>()
+            ip1test1()
             test4()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.<!AMBIGUITY!>test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.test1()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.<!AMBIGUITY!>test2<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.test2()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.<!AMBIGUITY!>ip1test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.ip1test1()
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.test4()
         }
         also {
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.<!AMBIGUITY!>test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.test1()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.<!AMBIGUITY!>test2<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.test2()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.<!AMBIGUITY!>ip1test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.ip1test1()
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.test4()
         }
     }

compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/13.fir.kt

@@ -4305,31 +4305,31 @@ class Case61_3<T>: InterfaceWithTypeParameter1<T>, Case61_1<T>, Case61_2<T> {
 
 fun <T> T.case_61(x: T) where T : InterfaceWithTypeParameter1<T>?, T: Case61_3<T>?, T: Case61_1<T>?, T: Case61_2<T>? {
     if (x != null) {
-        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T")!>x<!>.<!AMBIGUITY!>ip1test1<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T")!>x<!>.ip1test1()
-        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T")!>x<!>.<!AMBIGUITY!>test2<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T")!>x<!>.test2()
-        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T")!>x<!>.<!AMBIGUITY!>ip1test1<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T")!>x<!>.ip1test1()
         <!DEBUG_INFO_EXPRESSION_TYPE("T!! & T")!>x<!>.test4()
 
-        x.<!AMBIGUITY!>ip1test1<!>()
+        x.ip1test1()
-        x.<!AMBIGUITY!>test2<!>()
+        x.test2()
-        x.<!AMBIGUITY!>ip1test1<!>()
+        x.ip1test1()
         x.test4()
         x.apply {
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>
-            <!AMBIGUITY!>ip1test1<!>()
+            ip1test1()
-            <!AMBIGUITY!>test2<!>()
+            test2()
-            <!AMBIGUITY!>ip1test1<!>()
+            ip1test1()
             test4()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.<!AMBIGUITY!>ip1test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.ip1test1()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.<!AMBIGUITY!>test2<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.test2()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.<!AMBIGUITY!>ip1test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.ip1test1()
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>this<!>.test4()
         }
         x.also {
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.<!AMBIGUITY!>ip1test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.ip1test1()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.<!AMBIGUITY!>test2<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.test2()
-            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.<!AMBIGUITY!>ip1test1<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.ip1test1()
             <!DEBUG_INFO_EXPRESSION_TYPE("T!!")!>it<!>.test4()
         }
     }