[API Usage] Use type refinements in overrides-related facilities

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

@@ -38,13 +38,16 @@ import org.jetbrains.kotlin.resolve.OverridingUtil.OverrideCompatibilityInfo.Res
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
+import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
+import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import org.jetbrains.kotlin.utils.addToStdlib.assertedCast
 import java.util.*
 
 class OverrideResolver(
     private val trace: BindingTrace,
     private val overridesBackwardCompatibilityHelper: OverridesBackwardCompatibilityHelper,
-    private val languageVersionSettings: LanguageVersionSettings
+    private val languageVersionSettings: LanguageVersionSettings,
+    private val kotlinTypeRefiner: KotlinTypeRefiner
 ) {
 
     fun check(c: TopDownAnalysisContext) {
@@ -270,7 +273,8 @@ class OverrideResolver(
         val overriddenDescriptors = declared.overriddenDescriptors
 
         if (hasOverrideNode) {
-            checkOverridesForMemberMarkedOverride(declared, object : CheckOverrideReportForDeclaredMemberStrategy {
+            checkOverridesForMemberMarkedOverride(
+                declared, kotlinTypeRefiner, object : CheckOverrideReportForDeclaredMemberStrategy {
                 private var finalOverriddenError = false
                 private var typeMismatchError = false
                 private var kindMismatchError = false
@@ -753,6 +757,7 @@ class OverrideResolver(
 
         private fun checkOverridesForMemberMarkedOverride(
             declared: CallableMemberDescriptor,
+            kotlinTypeRefiner: KotlinTypeRefiner,
             reportError: CheckOverrideReportForDeclaredMemberStrategy
         ) {
             val overriddenDescriptors = declared.overriddenDescriptors
@@ -765,7 +770,10 @@ class OverrideResolver(
                     "Overrides may only be resolved in a class, but $declared comes from $containingDeclaration"
                 }
 
-                val invisibleOverriddenDescriptor = findInvisibleOverriddenDescriptor(declared, declaringClass)
+                val invisibleOverriddenDescriptor =
+                    findInvisibleOverriddenDescriptor(
+                        declared, declaringClass, kotlinTypeRefiner
+                    )
                 if (invisibleOverriddenDescriptor != null) {
                     reportError.cannotOverrideInvisibleMember(declared, invisibleOverriddenDescriptor)
                 } else {
@@ -863,9 +871,11 @@ class OverrideResolver(
 
         private fun findInvisibleOverriddenDescriptor(
             declared: CallableMemberDescriptor,
-            declaringClass: ClassDescriptor
+            declaringClass: ClassDescriptor,
+            kotlinTypeRefiner: KotlinTypeRefiner
         ): CallableMemberDescriptor? {
-            for (supertype in declaringClass.typeConstructor.supertypes) {
+            @UseExperimental(TypeRefinement::class)
+            for (supertype in kotlinTypeRefiner.refineSupertypes(declaringClass)) {
                 val all = linkedSetOf<CallableMemberDescriptor>()
                 all.addAll(supertype.memberScope.getContributedFunctions(declared.name, NoLookupLocation.WHEN_CHECK_OVERRIDES))
                 all.addAll(supertype.memberScope.getContributedVariables(declared.name, NoLookupLocation.WHEN_CHECK_OVERRIDES))

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyClassContext.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.WrappedTypeFactory
+import org.jetbrains.kotlin.types.checker.NewKotlinTypeChecker
 
 interface LazyClassContext {
     val declarationScopeProvider: DeclarationScopeProvider
@@ -43,4 +44,5 @@ interface LazyClassContext {
     val syntheticResolveExtension: SyntheticResolveExtension
     val delegationFilter: DelegationFilter
     val wrappedTypeFactory: WrappedTypeFactory
+    val kotlinTypeChecker: NewKotlinTypeChecker
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java

@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
 import org.jetbrains.kotlin.resolve.scopes.MemberScope;
 import org.jetbrains.kotlin.storage.*;
 import org.jetbrains.kotlin.types.WrappedTypeFactory;
+import org.jetbrains.kotlin.types.checker.NewKotlinTypeChecker;
 import org.jetbrains.kotlin.utils.SmartList;
 
 import javax.inject.Inject;
@@ -84,6 +85,8 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
 
     private final SyntheticResolveExtension syntheticResolveExtension;
 
+    private final NewKotlinTypeChecker kotlinTypeChecker;
+
     private Project project;
 
     @Inject
@@ -153,7 +156,8 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
             @NotNull GlobalContext globalContext,
             @NotNull ModuleDescriptor rootDescriptor,
             @NotNull DeclarationProviderFactory declarationProviderFactory,
-            @NotNull BindingTrace delegationTrace
+            @NotNull BindingTrace delegationTrace,
+            @NotNull NewKotlinTypeChecker kotlinTypeChecker
     ) {
         LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager =
                 new LockBasedLazyResolveStorageManager(globalContext.getStorageManager());
@@ -194,6 +198,7 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         syntheticResolveExtension = SyntheticResolveExtension.Companion.getInstance(project);
 
         this.project = project;
+        this.kotlinTypeChecker = kotlinTypeChecker;
     }
 
     private LazyAnnotations createAnnotations(KtFile file, List<KtAnnotationEntry> annotationEntries) {
@@ -464,4 +469,10 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
     public void assertValid() {
         module.assertValid();
     }
+
+    @NotNull
+    @Override
+    public NewKotlinTypeChecker getKotlinTypeChecker() {
+        return kotlinTypeChecker;
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -151,7 +151,7 @@ open class LazyClassMemberScope(
         result: MutableCollection<D>,
         exactDescriptorClass: Class<out D>
     ) {
-        OverridingUtil.generateOverridesInFunctionGroup(
+        c.kotlinTypeChecker.overridingUtil.generateOverridesInFunctionGroup(
             name,
             fromSupertypes,
             ArrayList(result),

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.types.expressions
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
@@ -33,6 +32,7 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.debugText.getDebugText
@@ -51,6 +51,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.WrappedTypeFactory
+import org.jetbrains.kotlin.types.checker.NewKotlinTypeChecker
 
 class LocalClassifierAnalyzer(
     private val globalContext: GlobalContext,
@@ -65,7 +66,8 @@ class LocalClassifierAnalyzer(
     private val supertypeLoopChecker: SupertypeLoopChecker,
     private val languageVersionSettings: LanguageVersionSettings,
     private val delegationFilter: DelegationFilter,
-    private val wrappedTypeFactory: WrappedTypeFactory
+    private val wrappedTypeFactory: WrappedTypeFactory,
+    private val kotlinTypeChecker: NewKotlinTypeChecker
 ) {
     fun processClassOrObject(
         scope: LexicalWritableScope?,
@@ -98,7 +100,8 @@ class LocalClassifierAnalyzer(
                 languageVersionSettings,
                 SyntheticResolveExtension.getInstance(project),
                 delegationFilter,
-                wrappedTypeFactory
+                wrappedTypeFactory,
+                kotlinTypeChecker
             ),
             analyzerServices
         )
@@ -126,7 +129,8 @@ class LocalClassDescriptorHolder(
     val languageVersionSettings: LanguageVersionSettings,
     val syntheticResolveExtension: SyntheticResolveExtension,
     val delegationFilter: DelegationFilter,
-    val wrappedTypeFactory: WrappedTypeFactory
+    val wrappedTypeFactory: WrappedTypeFactory,
+    val kotlinTypeChecker: NewKotlinTypeChecker
 ) {
     // We do not need to synchronize here, because this code is used strictly from one thread
     private var classDescriptor: ClassDescriptor? = null
@@ -166,6 +170,7 @@ class LocalClassDescriptorHolder(
                     override val syntheticResolveExtension = this@LocalClassDescriptorHolder.syntheticResolveExtension
                     override val delegationFilter: DelegationFilter = this@LocalClassDescriptorHolder.delegationFilter
                     override val wrappedTypeFactory: WrappedTypeFactory = this@LocalClassDescriptorHolder.wrappedTypeFactory
+                    override val kotlinTypeChecker: NewKotlinTypeChecker = this@LocalClassDescriptorHolder.kotlinTypeChecker
                 },
                 containingDeclaration,
                 classOrObject.nameAsSafeName,