Added special error for incorrect KClass type in signatures.

2017-01-16 05:33:52 +03:00
parent 3d70d73964
commit 0ef1234f2e
11 changed files with 129 additions and 9 deletions
@@ -414,6 +414,11 @@ public interface Errors {
    DiagnosticFactory1<KtDeclaration, Collection<KotlinType>> AMBIGUOUS_ANONYMOUS_TYPE_INFERRED =
            DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);

+    DiagnosticFactory0<KtNamedDeclaration>
+            KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE = DiagnosticFactory0.create(ERROR, PositioningStrategies.DECLARATION_NAME);
+    DiagnosticFactory1<KtNamedDeclaration, TypeParameterDescriptor>
+            KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE = DiagnosticFactory1.create(ERROR, PositioningStrategies.DECLARATION_NAME);
+
    // Property-specific

    DiagnosticFactory2<KtNamedDeclaration, PropertyDescriptor, PropertyDescriptor> VAR_OVERRIDDEN_BY_VAL =
@@ -859,6 +859,9 @@ public class DefaultErrorMessages {
        MAP.put(DATA_CLASS_NOT_PROPERTY_PARAMETER, "Data class primary constructor must have only property (val / var) parameters");

        MAP.put(AMBIGUOUS_ANONYMOUS_TYPE_INFERRED, "Right-hand side has anonymous type. Please specify type explicitly", TO_STRING);
+        MAP.put(KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE, "Please specify type explicitly");
+        MAP.put(KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE,
+                "Please add upper bound Any for type parameter ''{0}'' or specify return type explicitly", NAME);

        MAP.put(EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED,
                "''{0}'' is a member and an extension at the same time. References to such elements are not allowed", NAME);
@@ -74,7 +74,8 @@ private val DEFAULT_DECLARATION_CHECKERS = listOf(
        SinceKotlinAnnotationValueChecker,
        ReifiedTypeParameterAnnotationChecker(),
        DynamicReceiverChecker,
-        DelegationChecker()
+        DelegationChecker(),
+        KClassWithIncorrectTypeArgumentChecker
 )

 private val DEFAULT_CALL_CHECKERS = listOf(
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.resolve.checkers
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.types.UnwrappedType
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
+import org.jetbrains.kotlin.types.typeUtil.builtIns
+import org.jetbrains.kotlin.types.typeUtil.contains
+
+object KClassWithIncorrectTypeArgumentChecker : SimpleDeclarationChecker {
+    override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink, bindingContext: BindingContext) {
+        if (descriptor !is CallableMemberDescriptor || descriptor.visibility == Visibilities.LOCAL) return
+
+        if (declaration !is KtCallableDeclaration || declaration.typeReference != null) return
+
+        // prevent duplicate reporting
+        if (descriptor is PropertyAccessorDescriptor) return
+
+        val returnType = descriptor.returnType ?: return
+
+        var typeParameterWithoutNotNullableUpperBound: TypeParameterDescriptor? = null
+        val thereIsBadKClassType = returnType.contains {
+            val kClassWithBadArgument = it.isKClassWithBadArgument()
+            if (kClassWithBadArgument) {
+                it.arguments.singleOrNull()?.type?.constructor?.declarationDescriptor?.let {
+                    if (it is TypeParameterDescriptor && it.containingDeclaration == descriptor) {
+                        typeParameterWithoutNotNullableUpperBound = it
+                    }
+                }
+            }
+
+            kClassWithBadArgument
+        }
+
+        if (typeParameterWithoutNotNullableUpperBound != null) {
+            diagnosticHolder.report(Errors.KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE.on(declaration, typeParameterWithoutNotNullableUpperBound!!))
+        }
+        else if (thereIsBadKClassType) {
+            diagnosticHolder.report(Errors.KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE.on(declaration))
+        }
+    }
+
+    private fun UnwrappedType.isKClassWithBadArgument(): Boolean {
+        val argumentType = arguments.singleOrNull()?.let { if (it.isStarProjection) null else it.type.unwrap() } ?: return false
+        val klass = (constructor.declarationDescriptor as? ClassDescriptor) ?: return false
+
+        return KotlinBuiltIns.isKClass(klass) && !KotlinTypeChecker.DEFAULT.isSubtypeOf(argumentType, argumentType.builtIns.anyType)
+    }
+}
@@ -23,8 +23,8 @@ class Test {
    fun <T> List<T>.testCallable4(): () -> Unit = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<T><!>?::<!UNSAFE_CALL!>foo<!>

    fun <T> List<T>.testClassLiteral1() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>a<T><!>::class
-    fun <T> List<T>.testClassLiteral2() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<!>?::class
-    fun <T> List<T>.testClassLiteral3() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<T, Any><!>::class
+    fun <T> List<T>.<!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>testClassLiteral2<!>() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<!>?::class
+    fun <T> List<T>.<!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>testClassLiteral3<!>() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<T, Any><!>::class

    fun <T> List<T>.testUnresolved1() = <!UNRESOLVED_REFERENCE!>unresolved<!><T>::<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>
    fun <T> List<T>.testUnresolved2() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>a<<!UNRESOLVED_REFERENCE!>unresolved<!>><!>::foo
@@ -2,11 +2,11 @@

 class A

-val a1 = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>A?::class<!>
-val a2 = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>A??::class<!>
+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 l1 = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>List<String>?::class<!>
-val l2 = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>List?::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<!>

 fun <T : Any> foo() {
    val t1 = <!TYPE_PARAMETER_AS_REIFIED!>T::class<!>
@@ -0,0 +1,23 @@
+// !DIAGNOSTICS: -TYPE_PARAMETER_AS_REIFIED -TYPE_PARAMETER_OF_PROPERTY_NOT_USED_IN_RECEIVER -UNUSED_VARIABLE -UNUSED_PARAMETER
+
+fun <T> <!KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE!>test1<!>() = T::class
+fun <T : Any> test2() = T::class
+
+val <T> <!KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE!>test3<!> = T::class
+val <T> <!KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE!>test4<!> get() = T::class
+
+fun <T> <!KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE!>test5<!>() = listOf(T::class)
+
+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 <T> listOf(e: T): List<T> = null!!
+
+fun <L> locals() {
+    fun <T> test1() = T::class
+    fun <T : Any> test2() = T::class
+
+    val test3 = L::class
+    fun test4() = L::class
+}
@@ -0,0 +1,12 @@
+package
+
+public val </*0*/ T> test3: kotlin.reflect.KClass<T>
+public val </*0*/ T> test4: kotlin.reflect.KClass<T>
+public fun </*0*/ T> listOf(/*0*/ e: T): kotlin.collections.List<T>
+public fun </*0*/ L> locals(): kotlin.Unit
+public fun </*0*/ T> test1(): kotlin.reflect.KClass<T>
+public fun </*0*/ T : kotlin.Any> test2(): kotlin.reflect.KClass<T>
+public fun </*0*/ T> test5(): kotlin.collections.List<kotlin.reflect.KClass<T>>
+public fun </*0*/ T> test6(): kotlin.reflect.KClass<T>
+public fun </*0*/ T> test7(): kotlin.reflect.KClass<*>
+public fun test8(): kotlin.reflect.KClass<kotlin.String?>
@@ -9,6 +9,6 @@ val ok3 = O::class


 val fail1 = <!UNSUPPORTED_FEATURE!>""<!>::class
-val fail2 = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>String?::class<!>
+val <!KCLASS_WITH_NULLABLE_ARGUMENT_IN_SIGNATURE!>fail2<!> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>String?::class<!>
 val fail3 = <!UNSUPPORTED_FEATURE!>(C)<!>::class
 val fail4 = <!UNSUPPORTED_FEATURE!>(C.Companion)<!>::class
@@ -5434,6 +5434,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                doTest(fileName);
            }

+            @TestMetadata("kClassInSignature.kt")
+            public void testKClassInSignature() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kClassInSignature.kt");
+                doTest(fileName);
+            }
+
            @TestMetadata("kt1141.kt")
            public void testKt1141() throws Exception {
                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt");
@@ -9,7 +9,7 @@ external class A {
 inline fun getA() = A::class
 inline fun getB() = foo<A.B>()

-inline fun <reified T> foo() = T::class
+inline fun <reified T : Any> foo() = T::class

 fun box(): String {
    if (getA() != A::class) return "fail1"