From 800d594a4f50462e46ae17b53e433619fc4bc32c Mon Sep 17 00:00:00 2001 From: Ivan Kochurkin Date: Mon, 29 Nov 2021 22:47:44 +0300 Subject: [PATCH] [FIR] Check adding default error messages for all diagnostics ^KT-49973 fixed Also, check for duplicates --- .../diagnostics/KtFirDataClassConverters.kt | 6 +- .../api/fir/diagnostics/KtFirDiagnostics.kt | 4 +- .../fir/diagnostics/KtFirDiagnosticsImpl.kt | 4 +- .../diagnostics/FirDiagnosticsList.kt | 7 +- .../jvm/FirJvmErrorsDefaultMessages.kt | 20 ++- .../fir/analysis/diagnostics/FirErrors.kt | 4 +- ...esExtensionPropertyTypeParameterChecker.kt | 18 +-- .../diagnostics/FirErrorsDefaultMessages.kt | 126 ++++++++++++++++-- .../FirErrorsDefaultMessagesHelper.kt | 19 +++ .../KtDiagnosticFactoryToRendererMap.kt | 7 + .../jetbrains/kotlin/diagnostics/Errors.java | 4 +- .../rendering/DefaultErrorMessages.java | 1 - .../kotlin/resolve/DeclarationsChecker.kt | 39 +++--- .../useTypeParameterOfExtensionProperty.kt | 4 +- 14 files changed, 190 insertions(+), 73 deletions(-) create mode 100644 compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessagesHelper.kt diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt index ef54d696b6e..7f42b4360e0 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -2539,13 +2539,13 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } - add(FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER) { firDiagnostic -> - DelegateUsesExtensionPropertyTypeParameterImpl( + add(FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER.errorFactory) { firDiagnostic -> + DelegateUsesExtensionPropertyTypeParameterErrorImpl( firDiagnostic as KtPsiDiagnostic, token, ) } - add(FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_WARNING) { firDiagnostic -> + add(FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER.warningFactory) { firDiagnostic -> DelegateUsesExtensionPropertyTypeParameterWarningImpl( firDiagnostic as KtPsiDiagnostic, token, diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt index ec510f63dc7..5aa6aa3e67a 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt @@ -1798,8 +1798,8 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract val actualType: KtType } - abstract class DelegateUsesExtensionPropertyTypeParameter : KtFirDiagnostic() { - override val diagnosticClass get() = DelegateUsesExtensionPropertyTypeParameter::class + abstract class DelegateUsesExtensionPropertyTypeParameterError : KtFirDiagnostic() { + override val diagnosticClass get() = DelegateUsesExtensionPropertyTypeParameterError::class } abstract class DelegateUsesExtensionPropertyTypeParameterWarning : KtFirDiagnostic() { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index 2246aae67e9..584f39cc424 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -2161,10 +2161,10 @@ internal class WrongSetterParameterTypeImpl( override val token: ValidityToken, ) : KtFirDiagnostic.WrongSetterParameterType(), KtAbstractFirDiagnostic -internal class DelegateUsesExtensionPropertyTypeParameterImpl( +internal class DelegateUsesExtensionPropertyTypeParameterErrorImpl( override val firDiagnostic: KtPsiDiagnostic, override val token: ValidityToken, -) : KtFirDiagnostic.DelegateUsesExtensionPropertyTypeParameter(), KtAbstractFirDiagnostic +) : KtFirDiagnostic.DelegateUsesExtensionPropertyTypeParameterError(), KtAbstractFirDiagnostic internal class DelegateUsesExtensionPropertyTypeParameterWarningImpl( override val firDiagnostic: KtPsiDiagnostic, diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt index 885a9fb783a..42218e687a5 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt @@ -917,8 +917,10 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { parameter("expectedType") parameter("actualType") } - val DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER by error(PositioningStrategy.PROPERTY_DELEGATE) - val DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_WARNING by warning(PositioningStrategy.PROPERTY_DELEGATE) + val DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER by deprecationError( + LanguageFeature.ForbidUsingExtensionPropertyTypeParameterInDelegate, + PositioningStrategy.PROPERTY_DELEGATE + ) val INITIALIZER_TYPE_MISMATCH by error(PositioningStrategy.PROPERTY_INITIALIZER) { parameter("expectedType") parameter("actualType") @@ -956,6 +958,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val EXPECTED_ENUM_CONSTRUCTOR by error>() val EXPECTED_ENUM_ENTRY_WITH_BODY by error() val EXPECTED_PROPERTY_INITIALIZER by error() + // TODO: need to cover `by` as well as delegate expression val EXPECTED_DELEGATED_PROPERTY by error() val EXPECTED_LATEINIT_PROPERTY by error(PositioningStrategy.LATEINIT_MODIFIER) diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrorsDefaultMessages.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrorsDefaultMessages.kt index 7692443308b..775b0d6db15 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrorsDefaultMessages.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/diagnostics/jvm/FirJvmErrorsDefaultMessages.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.STRING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.RENDER_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.SYMBOL +import org.jetbrains.kotlin.fir.analysis.diagnostics.checkMissingMessages import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.CONFLICTING_JVM_DECLARATIONS import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET @@ -31,6 +32,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.INAPPLICAB import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.INNER_JVM_RECORD import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET +import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JAVA_SAM_INTERFACE_CONSTRUCTOR_REFERENCE import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JAVA_TYPE_MISMATCH import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_DEFAULT_IN_DECLARATION import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors.JVM_DEFAULT_IN_JVM6_TARGET @@ -231,18 +233,6 @@ object FirJvmErrorsDefaultMessages : BaseDiagnosticRendererFactory() { SUBCLASS_CANT_CALL_COMPANION_PROTECTED_NON_STATIC, "Using protected members which are not @JvmStatic in the superclass companion is unsupported yet" ) - map.put( - DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET, - "Super calls to Java default methods are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'" - ) - map.put( - INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET, - "Calls to static methods in Java interfaces are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'" - ) - map.put( - INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER, - "Interfaces can call default methods via super only within @JvmDefault members. Please annotate the containing interface member with @JvmDefault" - ) map.put( REPEATABLE_CONTAINER_MUST_HAVE_VALUE_ARRAY, @@ -289,5 +279,11 @@ object FirJvmErrorsDefaultMessages : BaseDiagnosticRendererFactory() { SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL, "Spread operator is prohibited for arguments to signature-polymorphic calls" ) + map.put( + JAVA_SAM_INTERFACE_CONSTRUCTOR_REFERENCE, + "Java SAM interface constructor references are prohibited" + ) + + map.checkMissingMessages(FirJvmErrors) } } \ No newline at end of file diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index 46c3d3f8bb9..b8bdf64ad4f 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -10,6 +10,7 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageFeature.ForbidExposingTypesInPrimaryConstructorProperties +import org.jetbrains.kotlin.config.LanguageFeature.ForbidUsingExtensionPropertyTypeParameterInDelegate import org.jetbrains.kotlin.config.LanguageFeature.ProhibitAssigningSingleElementsToVarargsInNamedForm import org.jetbrains.kotlin.config.LanguageFeature.ProhibitConfusingSyntaxInWhenBranches import org.jetbrains.kotlin.config.LanguageFeature.ProhibitInvisibleAbstractMethodsInSuperclasses @@ -502,8 +503,7 @@ object FirErrors { val CONST_VAL_WITHOUT_INITIALIZER by error0(SourceElementPositioningStrategies.CONST_MODIFIER) val CONST_VAL_WITH_NON_CONST_INITIALIZER by error0() val WRONG_SETTER_PARAMETER_TYPE by error2() - val DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER by error0(SourceElementPositioningStrategies.PROPERTY_DELEGATE) - val DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_WARNING by warning0(SourceElementPositioningStrategies.PROPERTY_DELEGATE) + val DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER by deprecationError0(ForbidUsingExtensionPropertyTypeParameterInDelegate, SourceElementPositioningStrategies.PROPERTY_DELEGATE) val INITIALIZER_TYPE_MISMATCH by error3(SourceElementPositioningStrategies.PROPERTY_INITIALIZER) val GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY by error0(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) val SETTER_VISIBILITY_INCONSISTENT_WITH_PROPERTY_VISIBILITY by error0(SourceElementPositioningStrategies.VISIBILITY_MODIFIER) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt index 22704c55efc..01446e67313 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegateUsesExtensionPropertyTypeParameterChecker.kt @@ -5,15 +5,12 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration -import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactory0 import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.expressions.FirFunctionCall -import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneType @@ -29,20 +26,7 @@ object FirDelegateUsesExtensionPropertyTypeParameterChecker : FirPropertyChecker val shouldReportError = delegate.typeRef.coneType.containsTypeParameterFrom(parameters, delegate, context, reporter) if (shouldReportError) { - val diagnostic = getProperDiagnostic(context) - reporter.reportOn(declaration.source, diagnostic, context) - } - } - - private fun getProperDiagnostic(context: CheckerContext): KtDiagnosticFactory0 { - val reportAsError = context.session.languageVersionSettings.supportsFeature( - LanguageFeature.ForbidUsingExtensionPropertyTypeParameterInDelegate - ) - - return if (reportAsError) { - FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER - } else { - FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_WARNING + reporter.reportOn(declaration.source, FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt index 3a68606bf64..ef8a19e2d6d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt @@ -58,13 +58,17 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_ACTUALS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_ANONYMOUS_TYPE_INFERRED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_EXPECTS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_SUPER +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_KCLASS_LITERAL_OF_TYPE_PARAMETER_ERROR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_MUST_BE_CONST +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_CONSTRUCTOR_CALL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_MEMBER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ON_SUPERCLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_USED_AS_ANNOTATION_ARGUMENT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANONYMOUS_FUNCTION_WITH_NAME import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANONYMOUS_INITIALIZER_IN_INTERFACE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARGUMENT_PASSED_TWICE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARGUMENT_TYPE_MISMATCH @@ -72,6 +76,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARRAY_EQUALITY_OP import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNED_VALUE_IS_NEVER_READ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNMENT_IN_EXPRESSION_CONTEXT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNMENT_TYPE_MISMATCH import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGN_OPERATOR_AMBIGUITY @@ -130,12 +135,14 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DATA_CLASS_OVERRI import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DATA_CLASS_VARARG_PARAMETER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DATA_CLASS_WITHOUT_PARAMETERS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DECLARATION_CANT_BE_INLINED +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATED_PROPERTY_INSIDE_VALUE_CLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATED_PROPERTY_IN_INTERFACE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATE_SPECIAL_FUNCTION_AMBIGUITY import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATE_SPECIAL_FUNCTION_MISSING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATION_IN_INTERFACE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATION_NOT_TO_INTERFACE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR @@ -152,9 +159,12 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_TYPE_P import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATION_ERROR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DESERIALIZATION_ERROR +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DIVISION_BY_ZERO import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DSL_SCOPE_VIOLATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DUPLICATE_LABEL_IN_WHEN import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DYNAMIC_UPPER_BOUND +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ELSE_MISPLACED_IN_WHEN +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EMPTY_CHARACTER_LITERAL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EMPTY_RANGE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ENUM_ENTRY_AS_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EQUALITY_NOT_APPLICABLE @@ -185,6 +195,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_SUPER_CLA import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_SUPER_INTERFACE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPOSED_TYPE_PARAMETER_BOUND +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPRESSION_EXPECTED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPRESSION_EXPECTED_PACKAGE_FOUND import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED @@ -192,6 +203,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXTENSION_PROPERT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXTENSION_PROPERTY_WITH_BACKING_FIELD import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FINAL_SUPERTYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FINAL_UPPER_BOUND +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FLOAT_LITERAL_OUT_OF_RANGE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FORBIDDEN_VARARG_PARAMETER_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FUNCTION_CALL_EXPECTED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FUNCTION_DECLARATION_WITH_NO_NAME @@ -205,9 +217,14 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FUN_INTERFACE_WRO import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.GENERIC_THROWABLE_SUBCLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.HAS_NEXT_FUNCTION_AMBIGUITY +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.HAS_NEXT_FUNCTION_NONE_APPLICABLE +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.HAS_NEXT_MISSING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_CONST_EXPRESSION +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_DECLARATION_IN_WHEN_SUBJECT +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_ESCAPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_INLINE_PARAMETER_MODIFIER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_KOTLIN_VERSION_STRING_VALUE +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_PROJECTION_USAGE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_RESTRICTED_SUSPENDING_FUNCTION_CALL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_SELECTOR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_SUSPEND_FUNCTION_CALL @@ -230,6 +247,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCOMPATIBLE_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCOMPATIBLE_TYPES_WARNING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCONSISTENT_TYPE_PARAMETER_BOUNDS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCONSISTENT_TYPE_PARAMETER_VALUES +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCORRECT_CHARACTER_LITERAL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INC_DEC_SHOULD_NOT_RETURN_UNIT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INFERENCE_ERROR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INFIX_MODIFIER_REQUIRED @@ -243,6 +261,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INNER_CLASS_INSID import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INNER_CLASS_OF_GENERIC_THROWABLE_SUBCLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INSTANCE_ACCESS_BEFORE_SUPER_CALL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INTERFACE_WITH_SUPERCLASS +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INT_LITERAL_OUT_OF_RANGE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_CHARACTERS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_IF_AS_EXPRESSION @@ -251,6 +270,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVISIBLE_REFEREN import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVISIBLE_SETTER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.IS_ENUM_ENTRY import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ITERATOR_AMBIGUITY +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ITERATOR_MISSING +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ITERATOR_ON_NULLABLE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.LATEINIT_FIELD_IN_VAL_PROPERTY import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.LATEINIT_NULLABLE_BACKING_FIELD @@ -268,6 +289,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MANY_INTERFACES_M import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MANY_LAMBDA_EXPRESSION_ARGUMENTS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MISPLACED_TYPE_PARAMETER_CONSTRAINTS +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MISSING_STDLIB_CLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MISSING_VAL_ON_ANNOTATION_PARAMETER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MODIFIER_FORM_FOR_NON_BUILT_IN_SUSPEND import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MULTIPLE_VARARG_PARAMETERS @@ -281,8 +303,11 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NEWER_VERSION_IN_ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NEW_INFERENCE_ERROR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NEXT_AMBIGUITY +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NEXT_MISSING +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NEXT_NONE_APPLICABLE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NONE_APPLICABLE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_EXHAUSTIVE_WHEN_STATEMENT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_FINAL_MEMBER_IN_FINAL_CLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_FINAL_MEMBER_IN_OBJECT @@ -326,7 +351,9 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_INLINE_P import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_SUPERTYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_IN_CLASS_LITERAL_LHS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_OF_ANNOTATION_MEMBER +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULL_FOR_NONNULL_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ONLY_ONE_CLASS_BOUND_ALLOWED +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OPERATOR_MODIFIER_REQUIRED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OPERATOR_RENAMED_ON_IMPORT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OPT_IN_ARGUMENT_IS_NOT_MARKER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OPT_IN_CAN_ONLY_BE_USED_AS_ANNOTATION @@ -348,7 +375,9 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERLOAD_RESOLUTI import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDE_BY_INLINE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDE_DEPRECATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDING_FINAL_MEMBER +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDING_FINAL_MEMBER_BY_DELEGATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PACKAGE_CANNOT_BE_IMPORTED +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PACKAGE_OR_CLASSIFIER_REDECLARATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PLATFORM_CLASS_MAPPED_TO_KOTLIN import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS @@ -416,6 +445,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMA import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMATCH_BY_DELEGATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMATCH_ON_INHERITANCE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RETURN_TYPE_MISMATCH_ON_OVERRIDE +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SAFE_CALL_WILL_CHANGE_NULLABILITY import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_CLASS_CONSTRUCTOR_CALL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_INHERITOR_IN_DIFFERENT_MODULE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SEALED_INHERITOR_IN_DIFFERENT_PACKAGE @@ -446,6 +476,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TAILREC_ON_VIRTUA import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TAIL_RECURSION_IN_TRY_IS_NOT_SUPPORTED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.THROWABLE_TYPE_MISMATCH import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOO_MANY_ARGUMENTS +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOPLEVEL_TYPEALIASES_ONLY import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPEALIAS_SHOULD_EXPAND_TO_CLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_ARGUMENTS_NOT_ALLOWED @@ -491,6 +522,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UPPER_BOUND_IS_EX import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UPPER_BOUND_VIOLATED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USAGE_IS_NOT_INLINABLE +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_CALL_ON_NOT_NULL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_CAST import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_ELVIS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_ELVIS_RIGHT_IS_NULL @@ -528,6 +560,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_ANNOTATION_ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_GETTER_RETURN_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_INVOCATION_KIND +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_LONG_SUFFIX import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_MODIFIER_CONTAINING_DECLARATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_MODIFIER_TARGET import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS @@ -561,6 +594,10 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(VARIABLE_EXPECTED, "Variable expected") map.put(DELEGATION_IN_INTERFACE, "Interfaces cannot use delegation") map.put(DELEGATION_NOT_TO_INTERFACE, "Only interfaces can be delegated to") + map.put( + DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, + "Delegated member ''{0}'' hides supertype override: {1}. Please specify proper override explicitly", SYMBOL, SYMBOL + ) map.put(NESTED_CLASS_NOT_ALLOWED, "{0} is not allowed here", TO_STRING) map.put(VAL_OR_VAR_ON_LOOP_PARAMETER, "''{0}'' on loop parameter is not allowed", TO_STRING) map.put(VAL_OR_VAR_ON_FUN_PARAMETER, "''{0}'' on function parameter is not allowed", TO_STRING) @@ -568,6 +605,18 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER, "''{0}'' on secondary constructor parameter is not allowed", TO_STRING) map.put(DEPRECATION, "''{0}'' is deprecated. {1}", SYMBOL, STRING) map.put(DEPRECATION_ERROR, "''{0}'' is deprecated. {1}", SYMBOL, STRING) + map.put(ASSIGNMENT_IN_EXPRESSION_CONTEXT, "Assignments are not expressions, and only expressions are allowed in this context") + map.put(EXPRESSION_EXPECTED, "Only expressions are allowed here") + + map.put(DIVISION_BY_ZERO, "Division by zero") + map.put(INT_LITERAL_OUT_OF_RANGE, "The value is out of range") + map.put(WRONG_LONG_SUFFIX, "Use 'L' instead of 'l'") + map.put(EMPTY_CHARACTER_LITERAL, "Empty character literal") + map.put(FLOAT_LITERAL_OUT_OF_RANGE, "The value is out of range") + map.put(INCORRECT_CHARACTER_LITERAL, "Incorrect character literal") + map.put(TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL, "Too many characters in a character literal") + map.put(ILLEGAL_ESCAPE, "Illegal escape") + map.put(NULL_FOR_NONNULL_TYPE, "Null can not be a value of a non-null type") // Unresolved map.put(INVISIBLE_REFERENCE, "Symbol {0} is invisible", SYMBOL) @@ -584,7 +633,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(DESERIALIZATION_ERROR, "Deserialization error") map.put(ERROR_FROM_JAVA_RESOLUTION, "Java resolution error") // map.put(UNKNOWN_CALLABLE_KIND, ...) // & -// map.put(MISSING_STDLIB_CLASS, ...) // & + map.put(MISSING_STDLIB_CLASS, "Missing stdlib class") map.put(NO_THIS, "'this' is not defined in this context") // Super @@ -633,7 +682,10 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(CLASS_IN_SUPERTYPE_FOR_ENUM, "Enum class cannot inherit from classes") map.put(SEALED_SUPERTYPE, "This type is sealed, so it can be inherited by only its own nested classes or objects") map.put(SEALED_SUPERTYPE_IN_LOCAL_CLASS, "{0} cannot extend a sealed {1}", STRING, CLASS_KIND) - map.put(SEALED_INHERITOR_IN_DIFFERENT_PACKAGE, "A class can only inherit from a sealed class or interface declared in the same package") + map.put( + SEALED_INHERITOR_IN_DIFFERENT_PACKAGE, + "A class can only inherit from a sealed class or interface declared in the same package" + ) map.put(SEALED_INHERITOR_IN_DIFFERENT_MODULE, "Inheritance of sealed classes or interfaces from different module is prohibited") map.put(CLASS_INHERITS_JAVA_SEALED_CLASS, "Inheritance of Java sealed classes is prohibited") @@ -659,7 +711,11 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { SYMBOL, RENDER_COLLECTION_OF_TYPES ) - map.put(AMBIGUOUS_SUPER, "Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super'", NOT_RENDERED) + map.put( + AMBIGUOUS_SUPER, + "Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super'", + NOT_RENDERED + ) // Constructor problems map.put(CONSTRUCTOR_IN_OBJECT, "Constructors are not allowed for objects") @@ -684,6 +740,12 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(ANNOTATION_USED_AS_ANNOTATION_ARGUMENT, "An annotation can't be used as the annotations argument") map.put(ANNOTATION_CLASS_MEMBER, "Members are not allowed in annotation class") map.put(ANNOTATION_ARGUMENT_MUST_BE_CONST, "An annotation argument must be a compile-time constant") + map.put(ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST, "An enum annotation argument must be a enum constant") + map.put(ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL, "An annotation argument must be a class literal (T::class)") + map.put( + ANNOTATION_ARGUMENT_KCLASS_LITERAL_OF_TYPE_PARAMETER_ERROR, + "Type parameter in a class literal is deprecated in an annotation argument" + ) map.put( ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, "Default value of annotation parameter must be a compile-time constant" @@ -832,6 +894,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(INCOMPATIBLE_MODIFIERS, "Modifier ''{0}'' is incompatible with ''{1}''", TO_STRING, TO_STRING) map.put(REDUNDANT_OPEN_IN_INTERFACE, "Modifier 'open' is redundant for abstract interface members") map.put(WRONG_MODIFIER_TARGET, "Modifier ''{0}'' is not applicable to ''{1}''", TO_STRING, STRING) + map.put(OPERATOR_MODIFIER_REQUIRED, "''operator'' modifier is required on ''{0}'' in ''{1}''", TO_STRING, STRING) map.put(INFIX_MODIFIER_REQUIRED, "''infix'' modifier is required on ''{0}''", TO_STRING) map.put(WRONG_MODIFIER_CONTAINING_DECLARATION, "Modifier ''{0}'' is not applicable inside ''{1}''", TO_STRING, STRING) map.put(DEPRECATED_MODIFIER_CONTAINING_DECLARATION, "Modifier ''{0}'' is deprecated inside ''{1}''", TO_STRING, STRING) @@ -890,12 +953,20 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { RENDER_TYPE, ) + map.put(ITERATOR_MISSING, "For-loop range must have an 'iterator()' method") + map.put(ITERATOR_ON_NULLABLE, "Not nullable value required to call an 'iterator()' method on for-loop range") + map.put(ITERATOR_AMBIGUITY, "Method ''iterator()'' is ambiguous for this expression: {0}", SYMBOLS) + + map.put(NEXT_MISSING, "Method ''next()'' cannot be called on ''iterator()''") + map.put(NEXT_AMBIGUITY, "Method ''next()'' is ambiguous for this expression: {0}", SYMBOLS) + map.put(NEXT_NONE_APPLICABLE, "None of the ''next()'' functions is applicable for ''iterator()'' of type ''{0}''", SYMBOLS) + // Ambiguity map.put(OVERLOAD_RESOLUTION_AMBIGUITY, "Overload resolution ambiguity between candidates: {0}", SYMBOLS) map.put(ASSIGN_OPERATOR_AMBIGUITY, "Ambiguity between assign operator candidates: {0}", SYMBOLS) - map.put(ITERATOR_AMBIGUITY, "Method ''iterator()'' is ambiguous for this expression: {0}", SYMBOLS) + map.put(HAS_NEXT_MISSING, "hasNext() cannot be called on iterator()") map.put(HAS_NEXT_FUNCTION_AMBIGUITY, "Method ''hasNext()'' is ambiguous for this expression: {0}", SYMBOLS) - map.put(NEXT_AMBIGUITY, "Method ''next()'' is ambiguous for this expression: {0}", SYMBOLS) + map.put(HAS_NEXT_FUNCTION_NONE_APPLICABLE, "None of the hasNext() functions is applicable for iterator() of type ''{0}''", SYMBOLS) map.put( UNRESOLVED_REFERENCE_WRONG_RECEIVER, "Unresolved reference. None of the following candidates is applicable because of receiver type mismatch: {0}", @@ -905,6 +976,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { // Types & type parameters map.put(RECURSION_IN_IMPLICIT_TYPES, "Recursion in implicit types") map.put(INFERENCE_ERROR, "Inference error") + map.put(ILLEGAL_PROJECTION_USAGE, "Illegal projection usage") map.put(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, "Projections are not allowed on type arguments of functions and properties") map.put(UPPER_BOUND_VIOLATED, "Type argument is not within its bounds: should be subtype of ''{0}''", RENDER_TYPE, RENDER_TYPE) map.put( @@ -1248,6 +1320,13 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { DECLARATION_NAME ) + map.put( + OVERRIDING_FINAL_MEMBER_BY_DELEGATION, + "''{0}'' implicitly overrides a final member ''{1}'' by delegation", + DECLARATION_NAME, + DECLARATION_NAME + ) + map.put( VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION, "Val-property ''{0}'' implicitly overrides a var-property ''{1}'' by delegation", @@ -1263,9 +1342,10 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { // Redeclarations map.put(MANY_COMPANION_OBJECTS, "Only one companion object is allowed per class") - map.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", SYMBOLS) // * - map.put(REDECLARATION, "Conflicting declarations: {0}", SYMBOLS) // * - map.put(METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE, "An interface may not implement a method of 'Any'") // & + map.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", SYMBOLS) + map.put(REDECLARATION, "Conflicting declarations: {0}", SYMBOLS) + map.put(PACKAGE_OR_CLASSIFIER_REDECLARATION, "Redeclaration: {0}", SYMBOLS) + map.put(METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE, "An interface may not implement a method of 'Any'") // Invalid local declarations map.put( @@ -1290,8 +1370,8 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without a body must be abstract", DECLARATION_NAME) map.put(PRIVATE_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without body cannot be private", DECLARATION_NAME) map.put(NON_MEMBER_FUNCTION_NO_BODY, "Function ''{0}'' must have a body", DECLARATION_NAME) - map.put(FUNCTION_DECLARATION_WITH_NO_NAME, "Function declaration must have a name") + map.put(ANONYMOUS_FUNCTION_WITH_NAME, "Anonymous functions with names are prohibited") map.put( ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE, @@ -1362,6 +1442,10 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { RENDER_TYPE, RENDER_TYPE ) + map.put( + DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER, + "It's forbidden using extension property type parameter in delegate" + ) map.put(INITIALIZER_TYPE_MISMATCH, "Initializer type mismatch: expected {0}, actual {1}", RENDER_TYPE, RENDER_TYPE, NOT_RENDERED) map.put(GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY, "Getter visibility must be the same as property visibility") map.put( @@ -1434,6 +1518,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(TYPE_CANT_BE_USED_FOR_CONST_VAL, "Const ''val'' has type ''{0}''. Only primitives and String are allowed", RENDER_TYPE) map.put(CONST_VAL_WITHOUT_INITIALIZER, "Const 'val' should have an initializer") map.put(CONST_VAL_WITH_NON_CONST_INITIALIZER, "Const 'val' initializer should be a constant value") + map.put(NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION, "Only 'const val' can be used in constant expressions") // Multi-platform projects map.put(EXPECTED_DECLARATION_WITH_BODY, "Expected declaration must not have a body") @@ -1446,7 +1531,6 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(EXPECTED_LATEINIT_PROPERTY, "Expected property cannot be lateinit") map.put(EXPECTED_PRIVATE_DECLARATION, "Expected declaration cannot be private") map.put(SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, "Expected classes cannot initialize supertypes") - map.put(EXPECTED_PRIVATE_DECLARATION, "Expected declaration cannot be private") map.put(IMPLEMENTATION_BY_DELEGATION_IN_EXPECT_CLASS, "Implementation by delegation in expected classes is prohibited") map.put(ACTUAL_TYPE_ALIAS_NOT_TO_CLASS, "Right-hand side of actual type alias should be a class, not another type alias") map.put( @@ -1560,6 +1644,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(SENSELESS_NULL_IN_WHEN, "Expression under 'when' is never equal to null") // Nullability + map.put(USELESS_CALL_ON_NOT_NULL, "Unsafe call on not null") map.put( UNSAFE_CALL, "Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type {0}", @@ -1590,6 +1675,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION, "Non-null assertion (!!) is called on a lambda expression") map.put(NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE, "Non-null assertion (!!) is called on a callable reference expression") map.put(UNNECESSARY_SAFE_CALL, "Unnecessary safe call on a non-null receiver of type {0}", RENDER_TYPE) + map.put(SAFE_CALL_WILL_CHANGE_NULLABILITY, "Safe call on a non-null receiver will have nullable type in future releases") map.put(UNEXPECTED_SAFE_CALL, "Safe-call is not allowed here") map.put(USELESS_ELVIS, "Elvis operator (?:) always returns the left operand of non-nullable type {0}", RENDER_TYPE) map.put(USELESS_ELVIS_RIGHT_IS_NULL, "Right operand of elvis operator (?:) is useless if it is null") @@ -1613,8 +1699,17 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { TO_STRING, WHEN_MISSING_CASES ) - map.put(COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT, "Deprecated syntax. Use '||' instead of commas in when-condition for 'when' without argument") + map.put(ELSE_MISPLACED_IN_WHEN, "'else' entry must be the last one in a when-expression") + map.put( + COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT, + "Deprecated syntax. Use '||' instead of commas in when-condition for 'when' without argument" + ) map.put(DUPLICATE_LABEL_IN_WHEN, "Duplicate label in when") + map.put( + ILLEGAL_DECLARATION_IN_WHEN_SUBJECT, + "Illegal variable declaration in 'when' subject: {0}. Should be a simple val with an initializer", + STRING + ) map.put( CONFUSING_BRANCH_CONDITION, "The logical expressions may be understood ambiguously in when with subject branches. Please wrap it with parenthesis" @@ -1854,7 +1949,10 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(RETURN_FOR_BUILT_IN_SUSPEND, "Using implicit label for this lambda is prohibited") // Label - map.put(REDUNDANT_LABEL_WARNING, "Label is redundant, because it can not be referenced in either ''break'', ''continue'', or ''return'' expression") + map.put( + REDUNDANT_LABEL_WARNING, + "Label is redundant, because it can not be referenced in either ''break'', ''continue'', or ''return'' expression" + ) // Extended checkers group map.put(REDUNDANT_VISIBILITY_MODIFIER, "Redundant visibility modifier") @@ -1872,5 +1970,9 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(ASSIGNED_VALUE_IS_NEVER_READ, "Assigned value is never read") map.put(VARIABLE_INITIALIZER_IS_REDUNDANT, "Initializer is redundant") map.put(VARIABLE_NEVER_READ, "Variable is never read") + + map.checkMissingMessages(FirErrors) } } + + diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessagesHelper.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessagesHelper.kt new file mode 100644 index 00000000000..b6b824a8fa8 --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessagesHelper.kt @@ -0,0 +1,19 @@ +/* + * 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.diagnostics + +import org.jetbrains.kotlin.diagnostics.AbstractKtDiagnosticFactory +import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap +import kotlin.reflect.full.memberProperties + +fun KtDiagnosticFactoryToRendererMap.checkMissingMessages(objectWithErrors: Any) { + for (property in objectWithErrors.javaClass.kotlin.memberProperties) { + val factory = property.getter.call(objectWithErrors) as? AbstractKtDiagnosticFactory + if (factory != null && !containsKey(factory)) { + throw IllegalStateException("No default diagnostic renderer is provided for ${property.name}") + } + } +} \ No newline at end of file diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/KtDiagnosticFactoryToRendererMap.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/KtDiagnosticFactoryToRendererMap.kt index db24e75c338..9e2bbb5e1ed 100644 --- a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/KtDiagnosticFactoryToRendererMap.kt +++ b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/KtDiagnosticFactoryToRendererMap.kt @@ -12,6 +12,10 @@ class KtDiagnosticFactoryToRendererMap(val name: String) { operator fun get(factory: AbstractKtDiagnosticFactory): KtDiagnosticRenderer? = renderersMap[factory] + fun containsKey(factory: AbstractKtDiagnosticFactory): Boolean { + return renderersMap.containsKey(factory) + } + fun put(factory: KtDiagnosticFactory0, message: String) { put(factory, SimpleKtDiagnosticRenderer(message)) } @@ -102,6 +106,9 @@ class KtDiagnosticFactoryToRendererMap(val name: String) { } private fun put(factory: AbstractKtDiagnosticFactory, renderer: KtDiagnosticRenderer) { + if (renderersMap.containsKey(factory)) { + throw IllegalStateException("Diagnostic renderer is already initialized for $factory") + } renderersMap[factory] = renderer } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 8764d23a56d..ec5ceb89aa7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -663,9 +663,7 @@ public interface Errors { DiagnosticFactory0 SETTER_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory0.create(ERROR); DiagnosticFactory2 WRONG_SETTER_PARAMETER_TYPE = DiagnosticFactory2.create(ERROR); - DiagnosticFactory1 DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_WARNING = - DiagnosticFactory1.create(WARNING); + DiagnosticFactoryForDeprecation1 DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ForbidUsingExtensionPropertyTypeParameterInDelegate); // Function-specific diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 1e5bd98488d..d8828cfa148 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -501,7 +501,6 @@ public class DefaultErrorMessages { MAP.put(USELESS_IS_CHECK, "Check for instance is always ''{0}''", TO_STRING); MAP.put(WRONG_SETTER_PARAMETER_TYPE, "Setter parameter type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE); MAP.put(DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER, "It's forbidden using extension property type parameter ''{0}'' in delegate", TO_STRING); - MAP.put(DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_WARNING, "Deprecation: delegate shouldn't use extension property type parameter ''{0}''", TO_STRING); MAP.put(WRONG_GETTER_RETURN_TYPE, "Getter return type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE); MAP.put(WRONG_SETTER_RETURN_TYPE, "Setter return type must be Unit"); MAP.put(NO_COMPANION_OBJECT, "Classifier ''{0}'' does not have a companion object, and thus must be initialized here", NAME); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt index aa309d1fcbd..7890245cd3a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt @@ -158,7 +158,7 @@ class DeclarationsChecker( for (typeParameter in typeAliasDescriptor.declaredTypeParameters) { if (typeParameter !in usedTypeAliasParameters) { val source = DescriptorToSourceUtils.descriptorToDeclaration(typeParameter) as? KtTypeParameter - ?: throw AssertionError("No source element for type parameter $typeParameter of $typeAliasDescriptor") + ?: throw AssertionError("No source element for type parameter $typeParameter of $typeAliasDescriptor") trace.report(UNUSED_TYPEALIAS_PARAMETER.on(source, typeParameter, expandedType)) } } @@ -206,7 +206,7 @@ class DeclarationsChecker( val upperBoundChecker: UpperBoundChecker ) : TypeAliasExpansionReportStrategy { private val typeReference = declaration.getTypeReference() - ?: throw AssertionError("Incorrect type alias declaration for $typeAliasDescriptor") + ?: throw AssertionError("Incorrect type alias declaration for $typeAliasDescriptor") override fun wrongNumberOfTypeArguments(typeAlias: TypeAliasDescriptor, numberOfParameters: Int) { // Do nothing: this should've been reported during type resolution. @@ -302,7 +302,8 @@ class DeclarationsChecker( val protectedIsAllowed = languageVersionSettings.supportsFeature(LanguageFeature.AllowSealedInheritorsInDifferentFilesOfSamePackage) if (!(visibilityKeyword == KtTokens.PRIVATE_KEYWORD || (protectedIsAllowed && visibilityKeyword == KtTokens.PROTECTED_KEYWORD))) { - val factory = if (protectedIsAllowed) NON_PRIVATE_OR_PROTECTED_CONSTRUCTOR_IN_SEALED else NON_PRIVATE_CONSTRUCTOR_IN_SEALED + val factory = + if (protectedIsAllowed) NON_PRIVATE_OR_PROTECTED_CONSTRUCTOR_IN_SEALED else NON_PRIVATE_CONSTRUCTOR_IN_SEALED trace.report(factory.on(visibilityModifier)) } } @@ -439,7 +440,7 @@ class DeclarationsChecker( if (conflictingTypes.size <= 1) continue val containingDeclaration = typeParameterDescriptor.containingDeclaration as? ClassDescriptor - ?: throw AssertionError("Not a class descriptor: " + typeParameterDescriptor.containingDeclaration) + ?: throw AssertionError("Not a class descriptor: " + typeParameterDescriptor.containingDeclaration) if (sourceElement is KtClassOrObject) { val delegationSpecifierList = sourceElement.getSuperTypeList() ?: continue trace.report( @@ -559,7 +560,8 @@ class DeclarationsChecker( private fun checkAnnotationClassMembers(classOrObject: KtClassOrObject) { for (declaration in classOrObject.declarations) { if (declaration !is KtClassOrObject || - !languageVersionSettings.supportsFeature(LanguageFeature.NestedClassesInAnnotations)) { + !languageVersionSettings.supportsFeature(LanguageFeature.NestedClassesInAnnotations) + ) { trace.report(ANNOTATION_CLASS_MEMBER.on(declaration)) } } @@ -665,7 +667,8 @@ class DeclarationsChecker( } } else if (classDescriptor.kind == ClassKind.INTERFACE && modifierList.hasModifier(KtTokens.OPEN_KEYWORD) && - propertyDescriptor.modality == Modality.ABSTRACT) { + propertyDescriptor.modality == Modality.ABSTRACT + ) { trace.report(REDUNDANT_OPEN_IN_INTERFACE.on(property)) } } @@ -729,11 +732,13 @@ class DeclarationsChecker( extensionReceiverType?.contains { it.constructor == typeParameter.typeConstructor } == true } if (usedParameter != null) { - if (languageVersionSettings.supportsFeature(LanguageFeature.ForbidUsingExtensionPropertyTypeParameterInDelegate)) { - trace.report(DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER.on(delegate, usedParameter.name.asString())) - } else { - trace.report(DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER_WARNING.on(delegate, usedParameter.name.asString())) - } + trace.report( + DELEGATE_USES_EXTENSION_PROPERTY_TYPE_PARAMETER.on( + languageVersionSettings, + delegate, + usedParameter.name.asString() + ) + ) } } } else { @@ -779,7 +784,8 @@ class DeclarationsChecker( val typeParameterList = function.typeParameterList val nameIdentifier = function.nameIdentifier if (typeParameterList != null && nameIdentifier != null && - typeParameterList.textRange.startOffset > nameIdentifier.textRange.startOffset) { + typeParameterList.textRange.startOffset > nameIdentifier.textRange.startOffset + ) { trace.report(DEPRECATED_TYPE_PARAMETER_SYNTAX.on(typeParameterList)) } checkTypeParameterConstraints(function) @@ -810,12 +816,14 @@ class DeclarationsChecker( } } if (!hasBody && !hasAbstractModifier && !hasExternalModifier && !inInterface && !isExpectClass && - diagnosticSuppressor.shouldReportNoBody(functionDescriptor)) { + diagnosticSuppressor.shouldReportNoBody(functionDescriptor) + ) { trace.report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor)) } } else /* top-level only */ { if (!function.hasBody() && !hasAbstractModifier && !hasExternalModifier && !functionDescriptor.isExpect && - diagnosticSuppressor.shouldReportNoBody(functionDescriptor)) { + diagnosticSuppressor.shouldReportNoBody(functionDescriptor) + ) { trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)) } } @@ -918,7 +926,8 @@ class DeclarationsChecker( } else { if (propertyDescriptor.isOverridable && accessorDescriptor.visibility == DescriptorVisibilities.PRIVATE - && propertyDescriptor.visibility != DescriptorVisibilities.PRIVATE) { + && propertyDescriptor.visibility != DescriptorVisibilities.PRIVATE + ) { if (propertyDescriptor.modality == Modality.ABSTRACT) { reportVisibilityModifierDiagnostics(tokens.values, Errors.PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY) } else { diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/useTypeParameterOfExtensionProperty.kt b/compiler/testData/diagnostics/tests/delegatedProperty/useTypeParameterOfExtensionProperty.kt index 5fb06da2678..37c46de9047 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/useTypeParameterOfExtensionProperty.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/useTypeParameterOfExtensionProperty.kt @@ -7,13 +7,13 @@ class Delegate { operator fun setValue(thisRef: Any?, kp: Any?, newValue: T) { v = newValue } } -var List.foo by Delegate() +var List.foo by Delegate() class Wrapper(val v: T? = null) operator fun Wrapper.getValue(thisRef: Any?, kp: Any?): T = v!! -val List.bar by Wrapper() +val List.bar by Wrapper() fun useString(s: String) {}