Report error on nullable type alias in class literal

#KT-15736 Fixed

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -630,6 +630,7 @@ public interface Errors {
 
     DiagnosticFactory0<KtExpression> CLASS_LITERAL_LHS_NOT_A_CLASS = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtExpression> ARRAY_CLASS_LITERAL_REQUIRES_ARGUMENT = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtExpression> NULLABLE_TYPE_IN_CLASS_LITERAL_LHS = DiagnosticFactory0.create(ERROR);
 
     // Destructuring-declarations
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -879,6 +879,7 @@ public class DefaultErrorMessages {
 
         MAP.put(CLASS_LITERAL_LHS_NOT_A_CLASS, "Only classes are allowed on the left hand side of a class literal");
         MAP.put(ARRAY_CLASS_LITERAL_REQUIRES_ARGUMENT, "Array class literal requires a type argument, please specify one in angle brackets");
+        MAP.put(NULLABLE_TYPE_IN_CLASS_LITERAL_LHS, "Type in a class literal must not be nullable");
 
         //Inline
         MAP.put(NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, "Public-API inline function cannot access non-public-API ''{0}''", SHORT_NAMES_IN_TYPES, SHORT_NAMES_IN_TYPES);

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

@@ -50,6 +50,7 @@ import org.jetbrains.kotlin.resolve.source.toSourceElement
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.createTypeInfo
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import java.lang.UnsupportedOperationException
 import java.util.*
@@ -110,24 +111,21 @@ class DoubleColonExpressionResolver(
         }
 
         val type = (result as DoubleColonLHS.Type).type
-        val reportError: Boolean
+        val descriptor = type.constructor.declarationDescriptor
         if (result.possiblyBareType.isBare) {
-            val descriptor = type.constructor.declarationDescriptor
             if (descriptor is ClassDescriptor && KotlinBuiltIns.isNonPrimitiveArray(descriptor)) {
                 c.trace.report(ARRAY_CLASS_LITERAL_REQUIRES_ARGUMENT.on(expression))
             }
-            reportError = false
-        }
-        else {
-            reportError = !isAllowedInClassLiteral(type)
         }
 
-
+        if (type is SimpleType && !type.isMarkedNullable && descriptor is TypeParameterDescriptor && !descriptor.isReified) {
-        val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type)
+            c.trace.report(TYPE_PARAMETER_AS_REIFIED.on(expression, descriptor))
-        if (type is SimpleType && !type.isMarkedNullable && typeParameterDescriptor != null && !typeParameterDescriptor.isReified) {
-            c.trace.report(TYPE_PARAMETER_AS_REIFIED.on(expression, typeParameterDescriptor))
         }
-        else if (type.isMarkedNullable || reportError) {
+        // Note that "T::class" is allowed for type parameter T without a non-null upper bound
+        else if ((TypeUtils.isNullableType(type) && descriptor !is TypeParameterDescriptor) || expression.hasQuestionMarks) {
+            c.trace.report(NULLABLE_TYPE_IN_CLASS_LITERAL_LHS.on(expression))
+        }
+        else if (!result.possiblyBareType.isBare && !isAllowedInClassLiteral(type)) {
             c.trace.report(CLASS_LITERAL_LHS_NOT_A_CLASS.on(expression))
         }
     }
@@ -438,7 +436,8 @@ class DoubleColonExpressionResolver(
             )
         }
         else {
-            TypeUtils.makeNullableAsSpecified(possiblyBareType.actualType, doubleColonExpression.hasQuestionMarks)
+            val actualType = possiblyBareType.actualType
+            if (doubleColonExpression.hasQuestionMarks) actualType.makeNullable() else actualType
         }
 
         return DoubleColonLHS.Type(type, possiblyBareType)

compiler/testData/diagnostics/tests/classLiteral/nonClassesOnLHS.kt

@@ -2,19 +2,19 @@
 
 class A
 
-val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>a1<!> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>A?::class<!>
+val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>a1<!> = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>A?::class<!>
-val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>a2<!> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>A??::class<!>
+val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>a2<!> = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>A??::class<!>
 
-val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>l1<!> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>List<String>?::class<!>
+val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>l1<!> = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>List<String>?::class<!>
-val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>l2<!> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>List?::class<!>
+val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>l2<!> = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>List?::class<!>
 
 fun <T : Any> foo() {
     val t1 = <!TYPE_PARAMETER_AS_REIFIED!>T::class<!>
-    val t2 = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>T?::class<!>
+    val t2 = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>T?::class<!>
 }
 
 inline fun <reified T : Any> bar() {
-    val t3 = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>T?::class<!>
+    val t3 = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>T?::class<!>
 }
 
 val m = Map<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>::class

compiler/testData/diagnostics/tests/classLiteral/typealiases.kt

@@ -0,0 +1,15 @@
+typealias TString = String
+fun f1() = TString::class
+
+typealias TNullableString = String?
+fun <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>f2<!>() = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>TNullableString::class<!>
+
+typealias TNullableTString = TString?
+typealias TTNullableTString = TNullableTString
+fun f3() = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>TTNullableTString::class<!>
+
+inline fun <reified T> f4(b: Boolean): Any {
+    <!TOPLEVEL_TYPEALIASES_ONLY!>typealias X = <!TYPEALIAS_SHOULD_EXPAND_TO_CLASS!>T<!><!>
+    <!TOPLEVEL_TYPEALIASES_ONLY!>typealias Y = <!TYPEALIAS_SHOULD_EXPAND_TO_CLASS!>T?<!><!>
+    return if (b) X::class else Y::class
+}

compiler/testData/diagnostics/tests/classLiteral/typealiases.txt

@@ -0,0 +1,10 @@
+package
+
+public fun f1(): kotlin.reflect.KClass<TString /* = kotlin.String */>
+public fun f2(): kotlin.reflect.KClass<TNullableString /* = kotlin.String? */>
+public fun f3(): kotlin.reflect.KClass<TTNullableTString /* = kotlin.String? */>
+public inline fun </*0*/ reified T> f4(/*0*/ b: kotlin.Boolean): kotlin.Any
+public typealias TNullableString = kotlin.String?
+public typealias TNullableTString = TString?
+public typealias TString = kotlin.String
+public typealias TTNullableTString = TNullableTString

compiler/testData/diagnostics/tests/declarationChecks/kClassInSignature.kt

@@ -10,7 +10,7 @@ fun <T> <!KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE!>test5<!>() = listOf(
 
 fun <T> test6(): kotlin.reflect.KClass<<!UPPER_BOUND_VIOLATED!>T<!>> = T::class
 fun <T> test7(): kotlin.reflect.KClass<*> = T::class
-fun <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>test8<!>() = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>String?::class<!>
+fun <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>test8<!>() = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>String?::class<!>
 
 fun <T> listOf(e: T): List<T> = null!!
 
@@ -20,4 +20,4 @@ fun <L> locals() {
 
     val test3 = L::class
     fun test4() = L::class
-}
+}

compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/boundClassLiteral.kt

@@ -9,6 +9,6 @@ val ok3 = O::class
 
 
 val fail1 = <!UNSUPPORTED_FEATURE!>""<!>::class
-val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>fail2<!> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>String?::class<!>
+val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>fail2<!> = <!NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>String?::class<!>
 val fail3 = <!UNSUPPORTED_FEATURE!>(C)<!>::class
 val fail4 = <!UNSUPPORTED_FEATURE!>(C.Companion)<!>::class

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

@@ -3064,6 +3064,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("typealiases.kt")
+            public void testTypealiases() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/typealiases.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("unresolvedClass.kt")
             public void testUnresolvedClass() throws Exception {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt");