Add reporting of the warnings based on Java annotations for expanded type aliases

Before that, such warnings weren't reported as the corresponding errors were reported during type inference (only original types took part there)

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonPlatform.kt

@@ -6,12 +6,13 @@
 package org.jetbrains.kotlin.analyzer.common
 
 import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.storage.StorageManager
 
 private object CommonPlatformConfigurator : PlatformConfiguratorBase() {
-    override fun configureModuleComponents(container: StorageComponentContainer) {}
+    override fun configureModuleComponents(container: StorageComponentContainer, languageVersionSettings: LanguageVersionSettings) {}
 }
 
 object CommonPlatformAnalyzerServices : PlatformDependentAnalyzerServices() {

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -73,7 +73,7 @@ fun StorageComponentContainer.configureModule(
 
     useInstance(nonTrivialPlatformVersion ?: TargetPlatformVersion.NoVersion)
 
-    analyzerServices.platformConfigurator.configureModuleComponents(this)
+    analyzerServices.platformConfigurator.configureModuleComponents(this, languageVersionSettings)
     analyzerServices.platformConfigurator.configureModuleDependentCheckers(this)
 
     for (extension in StorageComponentContainerContributor.getInstances(moduleContext.project)) {

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.resolve
 
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.DefaultImplementation
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
@@ -13,7 +12,9 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticFactory2
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory3
 import org.jetbrains.kotlin.diagnostics.Errors.UPPER_BOUND_VIOLATED
 import org.jetbrains.kotlin.diagnostics.Errors.UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION
+import org.jetbrains.kotlin.diagnostics.reportDiagnosticOnce
 import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtTypeReference
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.types.*
@@ -21,7 +22,28 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.containsTypeAliasParameters
 
 @DefaultImplementation(impl = UpperBoundChecker::class)
-open class UpperBoundChecker(val languageVersionSettings: LanguageVersionSettings) {
+open class UpperBoundChecker {
+    open fun checkBoundsOfExpandedTypeAlias(type: KotlinType, expression: KtExpression, trace: BindingTrace) {
+        // do nothing in the strict mode as the errors are already reported in the type inference if necessary
+    }
+
+    open fun checkBounds(
+        argumentReference: KtTypeReference?,
+        argumentType: KotlinType,
+        typeParameterDescriptor: TypeParameterDescriptor,
+        substitutor: TypeSubstitutor,
+        trace: BindingTrace,
+        typeAliasUsageElement: KtElement? = null,
+    ) {
+        if (typeParameterDescriptor.upperBounds.isEmpty()) return
+
+        val diagnosticsReporter = UpperBoundViolatedReporter(trace, argumentType, typeParameterDescriptor)
+
+        for (bound in typeParameterDescriptor.upperBounds) {
+            checkBound(bound, argumentType, argumentReference, substitutor, typeAliasUsageElement, diagnosticsReporter)
+        }
+    }
+
     fun checkBounds(typeReference: KtTypeReference, type: KotlinType, trace: BindingTrace) {
         if (type.isError) return
 
@@ -58,23 +80,6 @@ open class UpperBoundChecker(val languageVersionSettings: LanguageVersionSetting
         }
     }
 
-    open fun checkBounds(
-        argumentReference: KtTypeReference?,
-        argumentType: KotlinType,
-        typeParameterDescriptor: TypeParameterDescriptor,
-        substitutor: TypeSubstitutor,
-        trace: BindingTrace,
-        typeAliasUsageElement: KtElement? = null,
-    ) {
-        if (typeParameterDescriptor.upperBounds.isEmpty()) return
-
-        val diagnosticsReporter = UpperBoundViolatedReporter(trace, argumentType, typeParameterDescriptor)
-
-        for (bound in typeParameterDescriptor.upperBounds) {
-            checkBound(bound, argumentType, argumentReference, substitutor, typeAliasUsageElement, diagnosticsReporter)
-        }
-    }
-
     protected fun checkBound(
         bound: KotlinType,
         argumentType: KotlinType,
@@ -99,18 +104,17 @@ open class UpperBoundChecker(val languageVersionSettings: LanguageVersionSetting
 }
 
 class UpperBoundViolatedReporter(
-    val trace: BindingTrace,
-    val argumentType: KotlinType,
-    val typeParameterDescriptor: TypeParameterDescriptor? = null,
-    val baseDiagnostic: DiagnosticFactory2<KtTypeReference, KotlinType, KotlinType> = UPPER_BOUND_VIOLATED,
-    val diagnosticForTypeAliases: DiagnosticFactory3<KtElement, KotlinType, KotlinType, ClassifierDescriptor> = UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION
+    private val trace: BindingTrace,
+    private val argumentType: KotlinType,
+    private val typeParameterDescriptor: TypeParameterDescriptor,
+    private val baseDiagnostic: DiagnosticFactory2<KtTypeReference, KotlinType, KotlinType> = UPPER_BOUND_VIOLATED,
+    private val diagnosticForTypeAliases: DiagnosticFactory3<KtElement, KotlinType, KotlinType, ClassifierDescriptor> = UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION
 ) {
     fun report(typeArgumentReference: KtTypeReference, substitutedBound: KotlinType) {
-        trace.report(baseDiagnostic.on(typeArgumentReference, substitutedBound, argumentType))
+        trace.reportDiagnosticOnce(baseDiagnostic.on(typeArgumentReference, substitutedBound, argumentType))
     }
 
     fun reportForTypeAliasExpansion(callElement: KtElement, substitutedBound: KotlinType) {
-        if (typeParameterDescriptor == null) return
-        trace.report(diagnosticForTypeAliases.on(callElement, substitutedBound, argumentType, typeParameterDescriptor))
+        trace.reportDiagnosticOnce(diagnosticForTypeAliases.on(callElement, substitutedBound, argumentType, typeParameterDescriptor))
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/DiagnosticReporterByTrackingStrategy.kt

@@ -15,8 +15,6 @@ import org.jetbrains.kotlin.diagnostics.reportDiagnosticOnce
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isNull
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.UpperBoundChecker
-import org.jetbrains.kotlin.resolve.UpperBoundViolatedReporter
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCalleeExpressionIfAny
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.callUtil.reportTrailingLambdaErrorOr
@@ -395,8 +393,8 @@ class DiagnosticReporterByTrackingStrategy(
                 }
 
                 (position as? ExplicitTypeParameterConstraintPositionImpl)?.let {
-                    UpperBoundViolatedReporter(trace, error.upperKotlinType)
-                        .report((it.typeArgument as SimpleTypeArgumentImpl).typeReference, error.lowerKotlinType)
+                    val typeArgumentReference = (it.typeArgument as SimpleTypeArgumentImpl).typeReference
+                    trace.report(UPPER_BOUND_VIOLATED.on(typeArgumentReference, error.upperKotlinType, error.lowerKotlinType))
                 }
 
                 (position as? FixVariableConstraintPositionImpl)?.let {