[FIR] Implement CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS diagnostics, fix tests

2021-04-19 15:54:01 +03:00
parent f2f2df90aa
commit d54808e33f
13 changed files with 66 additions and 28 deletions
@@ -82,6 +82,10 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
        val NO_THIS by error<PsiElement>()
    }

+    val CALL_RESOLUTION by object : DiagnosticGroup("Call resolution") {
+        val CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS by error<KtExpression>()
+    }
+
    val SUPER by object : DiagnosticGroup("Super") {
        val SUPER_IS_NOT_AN_EXPRESSION by error<PsiElement>(PositioningStrategy.REFERENCED_NAME_BY_QUALIFIED)
        val SUPER_NOT_AVAILABLE by error<PsiElement>(PositioningStrategy.REFERENCED_NAME_BY_QUALIFIED)
@@ -105,6 +105,9 @@ object FirErrors {
    val MISSING_STDLIB_CLASS by error0<PsiElement>()
    val NO_THIS by error0<PsiElement>()

+    // Call resolution
+    val CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS by error0<KtExpression>()
+
    // Super
    val SUPER_IS_NOT_AN_EXPRESSION by error0<PsiElement>(SourceElementPositioningStrategies.REFERENCED_NAME_BY_QUALIFIED)
    val SUPER_NOT_AVAILABLE by error0<PsiElement>(SourceElementPositioningStrategies.REFERENCED_NAME_BY_QUALIFIED)
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.expression
+
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.declarations.isAbstract
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.types.coneType
+
+object FirConstructorCallChecker : FirFunctionCallChecker() {
+    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+        val constructorSymbol =
+            (expression.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirConstructorSymbol ?: return
+        val declarationClass = constructorSymbol.fir.returnTypeRef.coneType.toRegularClass(context.session)
+
+        if (declarationClass != null && declarationClass.isAbstract && declarationClass.classKind == ClassKind.CLASS) {
+            reporter.reportOn(expression.source, FirErrors.CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, context)
+        }
+    }
+}
@@ -71,6 +71,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONST_VAL_WITHOUT
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONST_VAL_WITH_DELEGATE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONST_VAL_WITH_GETTER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONST_VAL_WITH_NON_CONST_INITIALIZER
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CYCLIC_CONSTRUCTOR_DELEGATION_CALL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CYCLIC_GENERIC_UPPER_BOUND
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DATA_CLASS_NOT_PROPERTY_PARAMETER
@@ -345,6 +346,7 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
                "Cannot access ''{0}'' before superclass constructor has been called",
                TO_STRING
            )
+            map.put(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, "Cannot create an instance of an abstract class")

            // Supertypes
            map.put(ENUM_AS_SUPERTYPE, "Enum as supertype")
@@ -38,7 +38,8 @@ object CommonExpressionCheckers : ExpressionCheckers() {
    override val functionCallCheckers: Set<FirFunctionCallChecker>
        get() = setOf(
            FirConventionFunctionCallChecker,
-            FirDivisionByZeroChecker
+            FirDivisionByZeroChecker,
+            FirConstructorCallChecker
        )

    override val tryExpressionCheckers: Set<FirTryExpressionChecker>
@@ -56,6 +56,6 @@ abstract class B3(i: Int) {
 }

 fun foo(c: B3) {
-    val a = B3(1)
-    val b = B1(2, "s")
-}
+    val a = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B3(1)<!>
+    val b = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B1(2, "s")<!>
+}
@@ -2,8 +2,8 @@

 abstract class AbstractClass
 typealias Test1 = AbstractClass
-val test1 = Test1()
-val test1a = AbstractClass()
+val test1 = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>Test1()<!>
+val test1a = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>AbstractClass()<!>

 annotation class AnnotationClass
 typealias Test2 = AnnotationClass
@@ -1,20 +0,0 @@
-// !LANGUAGE: +NewInference
-// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
-// SKIP_TXT
-
-// TESTCASE NUMBER: 1
-abstract class Base0()
-
-abstract class Base1() {
-    abstract fun foo()
-}
-
-abstract class Base2(var b1: Any, val a1: Any) {
-    abstract fun foo()
-}
-
-fun case1() {
-    val b0 = Base0()
-    val b1 = Base1()
-    val b2 = Base2(1, "1")
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: +NewInference
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT
@@ -233,6 +233,12 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
            token,
        )
    }
+    add(FirErrors.CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS) { firDiagnostic ->
+        CreatingAnInstanceOfAbstractClassImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
    add(FirErrors.SUPER_IS_NOT_AN_EXPRESSION) { firDiagnostic ->
        SuperIsNotAnExpressionImpl(
            firDiagnostic as FirPsiDiagnostic<*>,
@@ -182,6 +182,10 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
        override val diagnosticClass get() = NoThis::class
    }

+    abstract class CreatingAnInstanceOfAbstractClass : KtFirDiagnostic<KtExpression>() {
+        override val diagnosticClass get() = CreatingAnInstanceOfAbstractClass::class
+    }
+
    abstract class SuperIsNotAnExpression : KtFirDiagnostic<PsiElement>() {
        override val diagnosticClass get() = SuperIsNotAnExpression::class
    }
@@ -270,6 +270,13 @@ internal class NoThisImpl(
    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }

+internal class CreatingAnInstanceOfAbstractClassImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.CreatingAnInstanceOfAbstractClass(), KtAbstractFirDiagnostic<KtExpression> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
 internal class SuperIsNotAnExpressionImpl(
    firDiagnostic: FirPsiDiagnostic<*>,
    override val token: ValidityToken,
@@ -169,6 +169,6 @@ abstract class B3(i: Int) {
 }

 fun foo(a: B3) {
-    val a = B3(1)
-    val b = B1(2, "s")
+    val a = <error descr="[CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS] Cannot create an instance of an abstract class">B3(1)</error>
+    val b = <error descr="[CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS] Cannot create an instance of an abstract class">B1(2, "s")</error>
 }