Report error on nullable type alias in class literal

#KT-15736 Fixed
2017-01-16 12:50:45 +03:00
parent 284b9d2ba6
commit 6a352a1da7
9 changed files with 53 additions and 21 deletions
@@ -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

@@ -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);
@@ -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)
        }

-
-        val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(type)
-        if (type is SimpleType && !type.isMarkedNullable && typeParameterDescriptor != null && !typeParameterDescriptor.isReified) {
-            c.trace.report(TYPE_PARAMETER_AS_REIFIED.on(expression, typeParameterDescriptor))
+        if (type is SimpleType && !type.isMarkedNullable && descriptor is TypeParameterDescriptor && !descriptor.isReified) {
+            c.trace.report(TYPE_PARAMETER_AS_REIFIED.on(expression, descriptor))
        }
-        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)
@@ -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!>a2<!> = <!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<!> = <!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!>l2<!> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>List?::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<!> = <!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
@@ -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
+}
@@ -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
@@ -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
-}
+}
@@ -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
@@ -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");