FIR: Fix scope intersection types

Otherwise overload resolution ambiguity is reported in the test

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

@@ -12,7 +12,10 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.impl.*
+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.scope
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -43,7 +46,9 @@ fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession)
         }
         is ConeRawType -> lowerBound.scope(useSiteSession, scopeSession)
         is ConeFlexibleType -> lowerBound.scope(useSiteSession, scopeSession)
-        is ConeIntersectionType -> FirCompositeScope(
+        is ConeIntersectionType -> FirSuperTypeScope.prepareSupertypeScope(
+            useSiteSession,
+            FirStandardOverrideChecker(useSiteSession),
             intersectedTypes.mapNotNullTo(mutableListOf()) {
                 it.scope(useSiteSession, scopeSession)
             }

compiler/fir/resolve/testData/resolve/intersectionScope.kt

@@ -0,0 +1,14 @@
+interface A {
+    fun foo()
+}
+
+abstract class B : A {
+    override fun foo() {}
+}
+
+interface C : A {}
+
+fun main(c: C) {
+    if (c !is B) return
+    c.foo()
+}

compiler/fir/resolve/testData/resolve/intersectionScope.txt

@@ -0,0 +1,25 @@
+FILE: intersectionScope.kt
+    public abstract interface A : R|kotlin/Any| {
+        public abstract fun foo(): R|kotlin/Unit|
+
+    }
+    public abstract class B : R|A| {
+        public constructor(): R|B| {
+            super<R|kotlin/Any|>()
+        }
+
+        public open override fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+    public abstract interface C : R|A| {
+    }
+    public final fun main(c: R|C|): R|kotlin/Unit| {
+        when () {
+            (R|<local>/c| !is R|B|) ->  {
+                ^main Unit
+            }
+        }
+
+        R|<local>/c|.R|/B.foo|()
+    }

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java

@@ -143,6 +143,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
         runTest("compiler/fir/resolve/testData/resolve/genericFunctions.kt");
     }
 
+    @TestMetadata("intersectionScope.kt")
+    public void testIntersectionScope() throws Exception {
+        runTest("compiler/fir/resolve/testData/resolve/intersectionScope.kt");
+    }
+
     @TestMetadata("intersectionTypes.kt")
     public void testIntersectionTypes() throws Exception {
         runTest("compiler/fir/resolve/testData/resolve/intersectionTypes.kt");

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -143,6 +143,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
         runTest("compiler/fir/resolve/testData/resolve/genericFunctions.kt");
     }
 
+    @TestMetadata("intersectionScope.kt")
+    public void testIntersectionScope() throws Exception {
+        runTest("compiler/fir/resolve/testData/resolve/intersectionScope.kt");
+    }
+
     @TestMetadata("intersectionTypes.kt")
     public void testIntersectionTypes() throws Exception {
         runTest("compiler/fir/resolve/testData/resolve/intersectionTypes.kt");

compiler/testData/codegen/box/increment/postfixIncrementOnShortSmartCast.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 public fun box() : String {
     var i : Short?
     i = 10

compiler/testData/diagnostics/tests/IncDec.fir.kt

@@ -23,9 +23,9 @@ class WrongIncDec() {
 fun testWrongIncDec() {
   var x = WrongIncDec()
   x++
-  <!AMBIGUITY!>++<!>x
+  ++x
   x--
-  <!AMBIGUITY!>--<!>x
+  --x
 }
 
 class UnitIncDec() {
@@ -43,4 +43,4 @@ fun testUnitIncDec() {
   x = x--
   x = ++x
   x = --x
-}
+}

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts/SmartcastAmbiguitites.fir.kt

@@ -10,7 +10,7 @@ class C() {
 fun test(a : Any?) {
   if (a is B) {
       if (a is C) {
-          a.<!AMBIGUITY!>bar<!>();
+          a.bar();
       }
   }
 }

compiler/testData/diagnostics/tests/generics/nullability/smartCasts.fir.kt

@@ -27,8 +27,8 @@ fun <T : CharSequence?> foo(x: T) {
     x.length
 
     if (x is String) {
-        x.<!AMBIGUITY!>length<!>
+        x.length
-        x?.<!AMBIGUITY!>length<!>
+        x?.length
 
         x.bar1()
         x.bar2()

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.fir.kt

@@ -31,6 +31,6 @@ import p.*
 
 fun test(b: B<String>?) {
     if (b is C) {
-        b?.<!AMBIGUITY!>foo<!>()
+        b?.foo()
     }
 }

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.fir.kt

@@ -33,6 +33,6 @@ import p.*
 
 fun test(b: B?) {
     if (b is C && b is D) {
-        b?.<!AMBIGUITY!>getParent<!>()
+        b?.getParent()
     }
 }

compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.fir.kt

@@ -4,31 +4,31 @@ fun intBinEq() {
     x += 1.toByte()
     x += 1.toShort()
     x += 1L
-    <!UNRESOLVED_REFERENCE!>x += 1f<!>
+    x += 1f
-    <!UNRESOLVED_REFERENCE!>x += 1.0<!>
+    x += 1.0
     <!UNRESOLVED_REFERENCE!>x *= 'a'<!>
-    <!UNRESOLVED_REFERENCE!>x *= 1.toByte()<!>
+    x *= 1.toByte()
-    <!UNRESOLVED_REFERENCE!>x *= 1.toShort()<!>
+    x *= 1.toShort()
-    <!UNRESOLVED_REFERENCE!>x *= 1L<!>
+    x *= 1L
-    <!UNRESOLVED_REFERENCE!>x *= 1f<!>
+    x *= 1f
-    <!UNRESOLVED_REFERENCE!>x *= 1.0<!>
+    x *= 1.0
 }
 
 fun shortBinEq() {
     var x = 0.toShort()
     <!UNRESOLVED_REFERENCE!>x += 'a'<!>
     x += 1.toByte()
-    <!UNRESOLVED_REFERENCE!>x += 1.toShort()<!>
+    x += 1.toShort()
-    <!UNRESOLVED_REFERENCE!>x += 1L<!>
+    x += 1L
-    <!UNRESOLVED_REFERENCE!>x += 1f<!>
+    x += 1f
-    <!UNRESOLVED_REFERENCE!>x += 1.0<!>
+    x += 1.0
 
     <!UNRESOLVED_REFERENCE!>x *= 'a'<!>
-    <!UNRESOLVED_REFERENCE!>x *= 1.toByte()<!>
+    x *= 1.toByte()
-    <!UNRESOLVED_REFERENCE!>x *= 1.toShort()<!>
+    x *= 1.toShort()
-    <!UNRESOLVED_REFERENCE!>x *= 1L<!>
+    x *= 1L
-    <!UNRESOLVED_REFERENCE!>x *= 1f<!>
+    x *= 1f
-    <!UNRESOLVED_REFERENCE!>x *= 1.0<!>
+    x *= 1.0
 }
 
 class A {

compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/simple.fir.kt

@@ -37,7 +37,7 @@ fun main(
     a.foo(it)
 
     // Iterators
-    a.<!AMBIGUITY!>foo<!>(ml.<!AMBIGUITY!>iterator<!>())
+    a.foo(ml.iterator())
     a.foo(l.iterator())
 
     // Sets

compiler/testData/diagnostics/tests/regressions/kt9682.fir.kt

@@ -15,7 +15,7 @@ interface IFoo {
 fun test() {
     val foo : Foo = Foo2()
     foo as IFoo
-    foo.<!AMBIGUITY!>bar<!>() // Should be resolved to Foo#bar
+    foo.bar() // Should be resolved to Foo#bar
 }
 
 interface IFoo2 {
@@ -24,5 +24,5 @@ interface IFoo2 {
 
 fun test2(foo: Foo) {
     foo as IFoo2
-    foo.<!AMBIGUITY!>bar<!>() // should be ambiguity
+    foo.bar() // should be ambiguity
-}
+}

compiler/testData/diagnostics/tests/scopes/stopResolutionOnAmbiguity.fir.kt

@@ -12,7 +12,7 @@ class C() {
 fun test(a : Any?) {
     if (a is B) {
         if (a is C) {
-            a.<!AMBIGUITY!>bar<!>();
+            a.bar();
         }
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictTypeParameters.fir.kt

@@ -8,6 +8,6 @@ interface B {
 
 fun test(c: Any) {
     if (c is B && c is A) {
-        c.<!AMBIGUITY!>foo<!><String, Int>()
+        c.foo<String, Int>()
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictingReturnType.fir.kt

@@ -10,6 +10,6 @@ interface B {
 
 fun test(c: Any) {
     if (c is B && c is A) {
-        c.<!AMBIGUITY!>foo<!>()
+        c.foo()
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.fir.kt

@@ -17,37 +17,37 @@ interface C {
 
 fun foo(x: Any?) {
     if (x is A && x is B) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String?>() }
+        x.foo().checkType { _<String?>() }
     }
 
     if (x is B && x is A) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String?>() }
+        x.foo().checkType { _<String?>() }
     }
 
     if (x is A && x is C) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foo().checkType { _<String>() }
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String?>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
     }
 
     if (x is C && x is A) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foo().checkType { _<String>() }
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String?>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
     }
 
     if (x is A && x is B && x is C) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foo().checkType { _<String>() }
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String?>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
     }
 
     if (x is B && x is A && x is C) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foo().checkType { _<String>() }
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String?>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
     }
 
     if (x is B && x is C && x is A) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foo().checkType { _<String>() }
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String?>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecific.fir.kt

@@ -14,6 +14,6 @@ interface B : Common {
 
 fun test(c: Common) {
     if (c is B && c is A) {
-        c.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        c.foo().checkType { _<String>() }
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecificIrrelevant.fir.kt

@@ -10,6 +10,6 @@ interface B {
 
 fun test(c: Any) {
     if (c is B && c is A) {
-        c.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        c.foo().checkType { _<String>() }
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/properties.fir.kt

@@ -13,9 +13,9 @@ interface B: A {
 
 fun test(a: A) {
     if (a is B && a is 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/smartCasts/intersectionScope/propertiesConflict.fir.kt

@@ -13,8 +13,8 @@ interface B: A {
 
 fun test(a: A) {
     if (a is B && a is C) {
-        a.<!AMBIGUITY!>foo<!> = ""
+        a.foo = ""
-        a.<!AMBIGUITY!>foo<!> = null
+        a.foo = null
-        a.<!AMBIGUITY!>foo<!>
+        a.foo
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.fir.kt

@@ -28,11 +28,11 @@ fun test() {
     x.foo().checkType { _<CharSequence?>() }
 
     if (x is B && x is C) {
-        x.<!AMBIGUITY!>foo<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><CharSequence?>() }
+        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><CharSequence?>() }
         x.baz("")
-        x.<!AMBIGUITY!>baz<!>(1).<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Unit>() }
+        x.baz(1).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Unit>() }
-        x.<!AMBIGUITY!>baz<!>(1, 2)
+        x.baz(1, 2)
 
-        x.<!AMBIGUITY!>foobar<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+        x.foobar().checkType { _<String>() }
     }
 }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/validTypeParameters.fir.kt

@@ -10,6 +10,6 @@ interface B {
 
 fun test(c: Any) {
     if (c is B && c is A) {
-        c.<!AMBIGUITY!>foo<!><String, Int>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+        c.foo<String, Int>().checkType { _<Int>() }
     }
 }