KT-14352 Record short reference to companion object via type alias,

so that it would be checked properly.

compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java

@@ -117,8 +117,8 @@ public interface BindingContext {
     WritableSlice<KtReferenceExpression, DeclarationDescriptor> REFERENCE_TARGET =
             new BasicWritableSlice<KtReferenceExpression, DeclarationDescriptor>(DO_NOTHING);
     // if 'A' really means 'A.Companion' then this slice stores class descriptor for A, REFERENCE_TARGET stores descriptor Companion in this case
-    WritableSlice<KtReferenceExpression, ClassDescriptor> SHORT_REFERENCE_TO_COMPANION_OBJECT =
-            new BasicWritableSlice<KtReferenceExpression, ClassDescriptor>(DO_NOTHING);
+    WritableSlice<KtReferenceExpression, ClassifierDescriptorWithTypeParameters> SHORT_REFERENCE_TO_COMPANION_OBJECT =
+            new BasicWritableSlice<KtReferenceExpression, ClassifierDescriptorWithTypeParameters>(DO_NOTHING);
 
     WritableSlice<Call, ResolvedCall<?>> RESOLVED_CALL = new BasicWritableSlice<Call, ResolvedCall<?>>(DO_NOTHING);
     WritableSlice<Call, TailRecursionKind> TAIL_RECURSION_CALL = Slices.createSimpleSlice();

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

@@ -89,7 +89,7 @@ private fun resolveQualifierReferenceTarget(
     }
 
     // TODO make decisions about short reference to companion object somewhere else
-    if (qualifier is ClassQualifier) {
+    if (qualifier is ClassifierQualifier) {
         val classifier = qualifier.descriptor
         val selectorIsCallable = selector is CallableDescriptor &&
                                  (selector.dispatchReceiverParameter != null || selector.extensionReceiverParameter != null)

compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ClassifierUsageChecker.kt

@@ -56,15 +56,17 @@ interface ClassifierUsageChecker {
 
                     val target = getReferencedClassifier(expression) ?: return
 
-                    for (checker in checkers) {
-                        checker.check(target, trace, expression, languageVersionSettings)
-                    }
+                    runCheckersWithTarget(target, expression)
 
                     if (isReferenceToCompanionViaOuterClass(expression, target)) {
                         val outerClass = target.containingDeclaration as ClassDescriptor
-                        for (checker in checkers) {
-                            checker.check(outerClass, trace, expression, languageVersionSettings)
-                        }
+                        runCheckersWithTarget(outerClass, expression)
+                    }
+                }
+
+                private fun runCheckersWithTarget(target: ClassifierDescriptor, expression: KtReferenceExpression) {
+                    for (checker in checkers) {
+                        checker.check(target, trace, expression, languageVersionSettings)
                     }
                 }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt

@@ -53,7 +53,9 @@ class TypeParameterQualifier(
     override fun toString() = "TypeParameter{$descriptor}"
 }
 
-interface ClassifierQualifier : Qualifier
+interface ClassifierQualifier : Qualifier {
+    override val descriptor: ClassifierDescriptorWithTypeParameters
+}
 
 class ClassQualifier(
         override val referenceExpression: KtSimpleNameExpression,

compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsCompanionObjects.kt

@@ -0,0 +1,15 @@
+// !API_VERSION: 1.0
+
+class C {
+    @SinceKotlin("1.1")
+    companion object {
+        val x = 42
+    }
+}
+
+typealias CA = C
+
+val test1 = <!NO_COMPANION_OBJECT!>CA<!>
+val test2 = CA.<!UNRESOLVED_REFERENCE!>Companion<!>
+val test3 = <!API_NOT_AVAILABLE!>CA<!>.x
+val test4 = CA.<!UNRESOLVED_REFERENCE!>Companion<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>

compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsCompanionObjects.txt

@@ -0,0 +1,22 @@
+package
+
+public val test1: [ERROR : Type for CA]
+public val test2: [ERROR : Type for CA.Companion]
+public val test3: kotlin.Int = 42
+public val test4: [ERROR : <ERROR PROPERTY TYPE>]
+
+public final class C {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    @kotlin.SinceKotlin(version = "1.1") public companion object Companion {
+        private constructor Companion()
+        public final val x: kotlin.Int = 42
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+public typealias CA = C

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -19574,6 +19574,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                     doTest(fileName);
                 }
 
+                @TestMetadata("typealiasesAsCompanionObjects.kt")
+                public void testTypealiasesAsCompanionObjects() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsCompanionObjects.kt");
+                    doTest(fileName);
+                }
+
                 @TestMetadata("typealiasesAsConstructors.kt")
                 public void testTypealiasesAsConstructors() throws Exception {
                     String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt");