azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Fix handling of WRONG_MODIFIER_TARGET

Browse Source 
Implement DEPRECATED_MODIFIER, DEPRECATED_MODIFIER_FOR_TARGET, REDUNDANT_MODIFIER_FOR_TARGET
This commit is contained in:
Ivan Kochurkin
2021-08-04 20:20:38 +03:00
committed by TeamCityServer
parent e85940a1ac
commit cd6384eb20
114 changed files with 504 additions and 1033 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/resolve/constVal/constValNotTopLevelOrObject.kt
Vendored
+1 -1
View File
@@ -38,5 +38,5 @@ object F {
}
fun foo() {
const val a = "2"
<!WRONG_MODIFIER_TARGET!>const<!> val a = "2"
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/infixFunctions.kt
Vendored
+3 -3
View File
@@ -6,11 +6,11 @@ infix fun Int.good(x: Int) {}
<!INAPPLICABLE_INFIX_MODIFIER!>infix fun baz(x: Int, y: Int) {}<!>
infix class A
<!WRONG_MODIFIER_TARGET!>infix<!> class A
infix typealias B = A
<!WRONG_MODIFIER_TARGET!>infix<!> typealias B = A
infix val x = 1
<!WRONG_MODIFIER_TARGET!>infix<!> val x = 1
class C {
infix fun good(x: Int) {}
compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantModalityModifierChecker.kt
Vendored
+1 -1
View File
@@ -82,4 +82,4 @@ abstract interface AbstractInterface
// Redundant final object
<!REDUNDANT_MODALITY_MODIFIER!>final<!> object FinalObject
// Open interface
open interface OpenInterface
<!REDUNDANT_MODIFIER_FOR_TARGET!>open<!> interface OpenInterface
compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantVisibilityModifierChecker.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
fun f() {
<!REDUNDANT_VISIBILITY_MODIFIER!>public<!> <!CAN_BE_VAL!>var<!> <!UNUSED_VARIABLE!>baz<!> = 0
<!REDUNDANT_VISIBILITY_MODIFIER, WRONG_MODIFIER_TARGET!>public<!> <!CAN_BE_VAL!>var<!> <!UNUSED_VARIABLE!>baz<!> = 0
class LocalClass {
<!REDUNDANT_VISIBILITY_MODIFIER!>internal<!> var foo = 0
}
compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassDeclaration.kt
Vendored
+1 -1
View File
@@ -1,7 +1,7 @@
class A {
<!INLINE_CLASS_NOT_TOP_LEVEL!>inline<!> inner class B(val x: Int)
fun foo() {
<!INLINE_CLASS_NOT_TOP_LEVEL!>inline<!> class C(val x: Int)
<!INLINE_CLASS_NOT_TOP_LEVEL, WRONG_MODIFIER_TARGET!>inline<!> class C(val x: Int)
}
inner <!INLINE_CLASS_NOT_TOP_LEVEL!>value<!> class D(val x: Int)
}
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+12
View File
@@ -307,10 +307,22 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
parameter<String>("redundantModifier")
parameter<String>("conflictingModifier")
}
val DEPRECATED_MODIFIER by warning<PsiElement> {
parameter<String>("deprecatedModifier")
parameter<String>("actualModifier")
}
val DEPRECATED_MODIFIER_PAIR by error<PsiElement> {
parameter<String>("deprecatedModifier")
parameter<String>("conflictingModifier")
}
val DEPRECATED_MODIFIER_FOR_TARGET by warning<PsiElement> {
parameter<String>("deprecatedModifier")
parameter<String>("target")
}
val REDUNDANT_MODIFIER_FOR_TARGET by warning<PsiElement> {
parameter<String>("redundantModifier")
parameter<String>("target")
}
val INCOMPATIBLE_MODIFIERS by error<PsiElement> {
parameter<String>("modifier1")
parameter<String>("modifier2")
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+3 -1
View File
@@ -37,7 +37,6 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.lexer.KtKeywordToken
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtAnnotationEntry
@@ -256,7 +255,10 @@ object FirErrors {
val INAPPLICABLE_INFIX_MODIFIER by error0<PsiElement>()
val REPEATED_MODIFIER by error1<PsiElement, String>()
val REDUNDANT_MODIFIER by error2<PsiElement, String, String>()
val DEPRECATED_MODIFIER by warning2<PsiElement, String, String>()
val DEPRECATED_MODIFIER_PAIR by error2<PsiElement, String, String>()
val DEPRECATED_MODIFIER_FOR_TARGET by warning2<PsiElement, String, String>()
val REDUNDANT_MODIFIER_FOR_TARGET by warning2<PsiElement, String, String>()
val INCOMPATIBLE_MODIFIERS by error2<PsiElement, String, String>()
val REDUNDANT_OPEN_IN_INTERFACE by warning0<KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)
val WRONG_MODIFIER_TARGET by error2<PsiElement, String, String>()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt
+81 -4
View File
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.*
@@ -33,13 +34,12 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.name.*
import org.jetbrains.kotlin.psi.KtModifierList
import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType
import org.jetbrains.kotlin.resolve.AnnotationTargetList
import org.jetbrains.kotlin.resolve.AnnotationTargetLists
import org.jetbrains.kotlin.types.AbstractTypeChecker
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.types.model.KotlinTypeMarker
@@ -671,3 +671,80 @@ fun FirFunctionSymbol<*>.isFunctionForExpectTypeFromCastFeature(): Boolean {
return true
}
fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
fun CallableId.isMember(): Boolean {
return classId != null || isLocal // TODO: Replace with .containingClass (after fixing)
}
return when (annotated) {
is FirRegularClass -> {
AnnotationTargetList(
KotlinTarget.classActualTargets(annotated.classKind, annotated.isInner, annotated.isCompanion, annotated.isLocal)
)
}
is FirEnumEntry -> AnnotationTargetList(
KotlinTarget.classActualTargets(ClassKind.ENUM_ENTRY, annotated.isInner, isCompanionObject = false, isLocalClass = false)
)
is FirProperty -> {
when {
annotated.isLocal ->
if (annotated.source?.kind == FirFakeSourceElementKind.DesugaredComponentFunctionCall) {
TargetLists.T_DESTRUCTURING_DECLARATION
} else {
TargetLists.T_LOCAL_VARIABLE
}
annotated.symbol.callableId.isMember() ->
if (annotated.source?.kind == FirFakeSourceElementKind.PropertyFromParameter) {
TargetLists.T_VALUE_PARAMETER_WITH_VAL
} else {
TargetLists.T_MEMBER_PROPERTY(annotated.hasBackingField, annotated.delegate != null)
}
else ->
TargetLists.T_TOP_LEVEL_PROPERTY(annotated.hasBackingField, annotated.delegate != null)
}
}
is FirValueParameter -> {
when {
annotated.hasValOrVar -> TargetLists.T_VALUE_PARAMETER_WITH_VAL
else -> TargetLists.T_VALUE_PARAMETER_WITHOUT_VAL
}
}
is FirConstructor -> TargetLists.T_CONSTRUCTOR
is FirAnonymousFunction -> {
TargetLists.T_FUNCTION_EXPRESSION
}
is FirSimpleFunction -> {
when {
annotated.isLocal -> TargetLists.T_LOCAL_FUNCTION
annotated.symbol.callableId.isMember() -> TargetLists.T_MEMBER_FUNCTION
else -> TargetLists.T_TOP_LEVEL_FUNCTION
}
}
is FirTypeAlias -> TargetLists.T_TYPEALIAS
is FirPropertyAccessor -> if (annotated.isGetter) TargetLists.T_PROPERTY_GETTER else TargetLists.T_PROPERTY_SETTER
is FirFile -> TargetLists.T_FILE
is FirTypeParameter -> TargetLists.T_TYPE_PARAMETER
is FirAnonymousInitializer -> TargetLists.T_INITIALIZER
is FirAnonymousObject ->
if (annotated.source?.kind == FirFakeSourceElementKind.EnumInitializer) {
AnnotationTargetList(
KotlinTarget.classActualTargets(
ClassKind.ENUM_ENTRY,
isInnerClass = false,
isCompanionObject = false,
isLocalClass = false
)
)
} else {
TargetLists.T_OBJECT_LITERAL
}
// TODO: properly implement those cases
// is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
// is KtDestructuringDeclaration -> TargetLists.T_DESTRUCTURING_DECLARATION
// is KtLambdaExpression -> TargetLists.T_FUNCTION_LITERAL
else -> TargetLists.EMPTY
}
}
private typealias TargetLists = AnnotationTargetLists
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt
+1 -67
View File
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
import org.jetbrains.kotlin.fir.analysis.checkers.getActualTargetList
import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
import org.jetbrains.kotlin.fir.analysis.diagnostics.*
import org.jetbrains.kotlin.fir.declarations.*
@@ -198,72 +199,5 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
}
}
}
private fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
return when (annotated) {
is FirRegularClass -> {
AnnotationTargetList(
KotlinTarget.classActualTargets(annotated.classKind, annotated.isInner, annotated.isCompanion, annotated.isLocal)
)
}
is FirEnumEntry -> AnnotationTargetList(
KotlinTarget.classActualTargets(ClassKind.ENUM_ENTRY, annotated.isInner, isCompanionObject = false, isLocalClass = false)
)
is FirProperty -> {
when {
annotated.isLocal ->
if (annotated.source?.kind == FirFakeSourceElementKind.DesugaredComponentFunctionCall) {
TargetLists.T_DESTRUCTURING_DECLARATION
} else {
TargetLists.T_LOCAL_VARIABLE
}
annotated.symbol.callableId.classId != null ->
if (annotated.source?.kind == FirFakeSourceElementKind.PropertyFromParameter) {
TargetLists.T_VALUE_PARAMETER_WITH_VAL
} else {
TargetLists.T_MEMBER_PROPERTY(annotated.hasBackingField, annotated.delegate != null)
}
else ->
TargetLists.T_TOP_LEVEL_PROPERTY(annotated.hasBackingField, annotated.delegate != null)
}
}
is FirValueParameter -> TargetLists.T_VALUE_PARAMETER_WITHOUT_VAL
is FirConstructor -> TargetLists.T_CONSTRUCTOR
is FirAnonymousFunction -> {
TargetLists.T_FUNCTION_EXPRESSION
}
is FirSimpleFunction -> {
when {
annotated.isLocal -> TargetLists.T_LOCAL_FUNCTION
annotated.symbol.callableId.classId != null -> TargetLists.T_MEMBER_FUNCTION
else -> TargetLists.T_TOP_LEVEL_FUNCTION
}
}
is FirTypeAlias -> TargetLists.T_TYPEALIAS
is FirPropertyAccessor -> if (annotated.isGetter) TargetLists.T_PROPERTY_GETTER else TargetLists.T_PROPERTY_SETTER
is FirFile -> TargetLists.T_FILE
is FirTypeParameter -> TargetLists.T_TYPE_PARAMETER
is FirAnonymousInitializer -> TargetLists.T_INITIALIZER
is FirAnonymousObject ->
if (annotated.source?.kind == FirFakeSourceElementKind.EnumInitializer) {
AnnotationTargetList(
KotlinTarget.classActualTargets(
ClassKind.ENUM_ENTRY,
isInnerClass = false,
isCompanionObject = false,
isLocalClass = false
)
)
} else {
TargetLists.T_OBJECT_LITERAL
}
// TODO: properly implement those cases
// is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE
// is KtDestructuringDeclaration -> TargetLists.T_DESTRUCTURING_DECLARATION
// is KtLambdaExpression -> TargetLists.T_FUNCTION_LITERAL
else -> TargetLists.EMPTY
}
}
}
private typealias TargetLists = AnnotationTargetLists
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirModifierChecker.kt
+96 -31
View File
@@ -5,61 +5,65 @@
package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.KtNodeTypes
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.analysis.checkers.FirModifier
import org.jetbrains.kotlin.fir.analysis.checkers.FirModifierList
import org.jetbrains.kotlin.fir.analysis.checkers.*
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.getModifierList
import org.jetbrains.kotlin.fir.analysis.checkers.getKeywordType
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory2
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
import org.jetbrains.kotlin.resolve.Compatibility
import org.jetbrains.kotlin.resolve.KeywordType
import org.jetbrains.kotlin.resolve.compatibility
import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor
import org.jetbrains.kotlin.fir.declarations.utils.hasBody
import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
import org.jetbrains.kotlin.fir.declarations.utils.isInner
import org.jetbrains.kotlin.fir.declarations.utils.isLocal
import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.resolve.*
object FirModifierChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirFile) return
val source = declaration.source ?: return
if (!isDeclarationMappedToSourceCorrectly(declaration, source)) return
if (context.containingDeclarations.last() is FirDefaultPropertyAccessor) return
if (source.kind is FirFakeSourceElementKind) return
val modifierList = source.getModifierList()
modifierList?.let { checkModifiers(it, declaration, reporter, context) }
}
if (declaration is FirProperty) {
fun checkPropertyAccessor(propertyAccessor: FirPropertyAccessor?) {
if (propertyAccessor != null && !propertyAccessor.hasBody) {
check(propertyAccessor, context, reporter)
}
}
private fun isDeclarationMappedToSourceCorrectly(declaration: FirDeclaration, source: FirSourceElement): Boolean =
when (source.elementType) {
KtNodeTypes.CLASS -> declaration is FirClass
KtNodeTypes.OBJECT_DECLARATION -> declaration is FirClass
KtNodeTypes.PROPERTY -> declaration is FirProperty
KtNodeTypes.VALUE_PARAMETER -> declaration is FirValueParameter
// TODO more FIR-PSI relations possibly have to be added
else -> true
checkPropertyAccessor(declaration.getter)
checkPropertyAccessor(declaration.setter)
}
source.getModifierList()?.let { checkModifiers(it, declaration, context, reporter) }
}
private fun checkModifiers(
list: FirModifierList,
owner: FirDeclaration,
reporter: DiagnosticReporter,
context: CheckerContext
context: CheckerContext,
reporter: DiagnosticReporter
) {
// general strategy: report no more than one error and any number of warnings
// therefore, a track of nodes with already reported errors should be kept
val reportedNodes = hashSetOf<FirModifier<*>>()
val actualTargets = getActualTargetList(owner).defaultTargets
val modifiers = list.modifiers
for (secondModifier in modifiers) {
for (firstModifier in modifiers) {
if (firstModifier == secondModifier) {
break
for ((secondIndex, secondModifier) in modifiers.withIndex()) {
for (firstIndex in 0 until secondIndex) {
checkCompatibilityType(modifiers[firstIndex], secondModifier, reporter, reportedNodes, owner, context)
}
if (secondModifier !in reportedNodes) {
when {
!checkTarget(modifierSource, modifierType, actualTargets, parent, context, reporter) -> reportedNodes += secondModifier
!checkParent(modifierSource, modifierType, actualParents, context, reporter) -> reportedNodes += secondModifier
}
checkCompatibilityType(firstModifier, secondModifier, reporter, reportedNodes, owner, context)
}
}
}
@@ -141,7 +145,68 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
}
}
private fun KeywordType.render(): String {
return this.toString().lowercase()
private fun checkTarget(
modifier: FirModifier<*>,
actualTargets: List<KotlinTarget>,
parent: FirDeclaration?,
context: CheckerContext,
reporter: DiagnosticReporter
): Boolean {
val modifierType = getKeywordType(modifier)
fun checkModifier(factory: FirDiagnosticFactory2<String, String>): Boolean {
val map = when (factory) {
FirErrors.WRONG_MODIFIER_TARGET -> possibleTargetMap
FirErrors.DEPRECATED_MODIFIER_FOR_TARGET -> deprecatedTargetMap
else -> redundantTargetMap
}
val set = map[modifierType] ?: emptySet()
val checkResult = if (factory == FirErrors.WRONG_MODIFIER_TARGET) {
actualTargets.none { it in set }
} else {
actualTargets.any { it in set }
}
if (checkResult) {
reporter.reportOn(
modifier.source,
factory,
modifierType.render(),
actualTargets.firstOrThis(),
context
)
return false
}
return true
}
if (!checkModifier(FirErrors.WRONG_MODIFIER_TARGET)) {
return false
}
if (parent is FirRegularClass) {
if (modifierType == KeywordType.Expect || modifierType == KeywordType.Header) {
reporter.reportOn(modifierSource, FirErrors.WRONG_MODIFIER_TARGET, modifierType.render(), "nested class", context)
return false
}
}
val deprecatedModifierReplacement = deprecatedModifierMap[modifierType]
if (deprecatedModifierReplacement != null) {
reporter.reportOn(
modifier.source,
FirErrors.DEPRECATED_MODIFIER,
modifierType.render(),
deprecatedModifierReplacement.render(),
context
)
} else if (checkModifier(FirErrors.DEPRECATED_MODIFIER_FOR_TARGET)) {
checkModifier(FirErrors.REDUNDANT_MODIFIER_FOR_TARGET)
}
return true
}
private fun List<KotlinTarget>.firstOrThis(): String {
return firstOrNull()?.description ?: "this"
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
+8 -3
View File
@@ -10,12 +10,12 @@ import org.jetbrains.kotlin.diagnostics.rendering.Renderers.RENDER_POSITION_VARI
import org.jetbrains.kotlin.diagnostics.rendering.Renderers.STRING
import org.jetbrains.kotlin.diagnostics.rendering.Renderers.commaSeparated
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.AMBIGUOUS_CALLS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.COLLECTION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.DECLARATION_NAME
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FIR
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FQ_NAMES_IN_TYPES
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.COLLECTION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.MODULE_DATA
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FUNCTION_PARAMETERS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.MODULE_DATA
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NOT_RENDERED
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NULLABLE_STRING
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.RENDER_CLASS_OR_OBJECT
@@ -125,6 +125,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DELEGATE_SPECIAL_
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
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_MODIFIER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_MODIFIER_FOR_TARGET
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_MODIFIER_PAIR
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_SINCE_KOTLIN_OUTSIDE_KOTLIN_SUBPACKAGE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_ARGUMENTS
@@ -340,6 +342,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_EXPLICI
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODALITY_MODIFIER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODIFIER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_MODIFIER_FOR_TARGET
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_OPEN_IN_INTERFACE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_PROJECTION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_RETURN_UNIT_TYPE
@@ -466,7 +469,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_MODIFIER_TA
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_NUMBER_OF_TYPE_ARGUMENTS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_SETTER_PARAMETER_TYPE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.WRONG_SETTER_RETURN_TYPE
import org.jetbrains.kotlin.name.StandardClassIds
@Suppress("unused")
class FirDefaultErrorMessages {
@@ -727,7 +729,10 @@ class FirDefaultErrorMessages {
map.put(INAPPLICABLE_INFIX_MODIFIER, "''infix'' modifier is inapplicable on this function")
map.put(REPEATED_MODIFIER, "Repeated ''{0}''", STRING)
map.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", STRING, STRING)
map.put(DEPRECATED_MODIFIER, "Modifier ''{0}'' is deprecated, use ''{1}'' instead", STRING, STRING)
map.put(DEPRECATED_MODIFIER_PAIR, "Modifier ''{0}'' is deprecated in presence of ''{1}''", STRING, STRING)
map.put(DEPRECATED_MODIFIER_FOR_TARGET, "Modifier ''{0}'' is deprecated for ''{1}''", STRING, STRING)
map.put(REDUNDANT_MODIFIER_FOR_TARGET, "Modifier ''{0}'' is redundant for ''{1}''", STRING, STRING)
map.put(INCOMPATIBLE_MODIFIERS, "Modifier ''{0}'' is incompatible with ''{1}''", STRING, 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}''", STRING, STRING)
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt
+1 -1
View File
@@ -1379,7 +1379,7 @@ class DeclarationsConverter(
}
return buildValueParameter {
source = setterParameter.toFirSourceElement()
source = firValueParameter.source
moduleData = baseModuleData
origin = FirDeclarationOrigin.Source
returnTypeRef = if (firValueParameter.returnTypeRef == implicitType) propertyTypeRef else firValueParameter.returnTypeRef
compiler/testData/diagnostics/tests/Abstract.fir.kt
Vendored
+19 -19
View File
@@ -3,44 +3,44 @@ package MyPackage
//properties
<!MUST_BE_INITIALIZED!>val a: Int<!>
val a1: Int = 1
abstract val a2: Int
abstract val a3: Int = 1
<!WRONG_MODIFIER_TARGET!>abstract<!> val a2: Int
<!WRONG_MODIFIER_TARGET!>abstract<!> val a3: Int = 1
<!MUST_BE_INITIALIZED!>var b: Int<!> private set
var b1: Int = 0; private set
abstract var b2: Int private set
abstract var b3: Int = 0; private set
<!WRONG_MODIFIER_TARGET!>abstract<!> var b2: Int private set
<!WRONG_MODIFIER_TARGET!>abstract<!> var b3: Int = 0; private set
<!MUST_BE_INITIALIZED!>var c: Int<!> set(v: Int) { field = v }
var c1: Int = 0; set(v: Int) { field = v }
abstract var c2: Int set(v: Int) { field = v }
abstract var c3: Int = 0; set(v: Int) { field = v }
<!WRONG_MODIFIER_TARGET!>abstract<!> var c2: Int set(v: Int) { field = v }
<!WRONG_MODIFIER_TARGET!>abstract<!> var c3: Int = 0; set(v: Int) { field = v }
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
abstract val e2: Int get() = a
abstract val e3: Int = 0; get() = a
<!WRONG_MODIFIER_TARGET!>abstract<!> val e2: Int get() = a
<!WRONG_MODIFIER_TARGET!>abstract<!> val e3: Int = 0; get() = a
//methods
<!NON_MEMBER_FUNCTION_NO_BODY!>fun f()<!>
fun g() {}
abstract fun h()
abstract fun j() {}
<!WRONG_MODIFIER_TARGET!>abstract<!> fun h()
<!WRONG_MODIFIER_TARGET!>abstract<!> fun j() {}
//property accessors
var i: Int abstract get abstract set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var i: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j: Int get() = i; abstract set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; abstract set
var j: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
<!MUST_BE_INITIALIZED!>var k: Int<!> abstract set
var k1: Int = 0; abstract set
<!MUST_BE_INITIALIZED!>var k: Int<!> <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k1: Int = 0; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l: Int abstract get abstract set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var l: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var n: Int abstract get abstract set(v: Int) {}
var n: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
// FILE: c.kt
//creating an instance
compiler/testData/diagnostics/tests/AbstractInAbstractClass.fir.kt
Vendored
-45
View File
@@ -1,45 +0,0 @@
package abstract
abstract class MyAbstractClass() {
//properties
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val a: Int<!>
val a1: Int = 1
abstract val a2: Int
abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var b: Int<!> private set
var b1: Int = 0; private set
abstract var b2: Int <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
<!MUST_BE_INITIALIZED!>var c: Int<!> set(v: Int) { field = v }
var c1: Int = 0; set(v: Int) { field = v }
abstract var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
abstract val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
//methods
<!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>fun f()<!>
fun g() {}
abstract fun h()
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int abstract get abstract set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var j: Int get() = i; abstract set
var j1: Int get() = i; abstract set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> abstract set
var k1: Int = 0; abstract set
var l: Int abstract get abstract set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var n: Int abstract get abstract set(v: Int) {}
}
compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package abstract
abstract class MyAbstractClass() {
compiler/testData/diagnostics/tests/AbstractInClass.fir.kt
Vendored
-45
View File
@@ -1,45 +0,0 @@
package abstract
class MyClass() {
//properties
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val a: Int<!>
val a1: Int = 1
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a2: Int
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val a3: Int = 1
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var b: Int<!> private set
var b1: Int = 0; private set
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b2: Int private set
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var b3: Int = 0; private set
<!MUST_BE_INITIALIZED!>var c: Int<!> set(v: Int) { field = v }
var c1: Int = 0; set(v: Int) { field = v }
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c2: Int set(v: Int) { field = v }
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> var c3: Int = 0; set(v: Int) { field = v }
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e2: Int get() = a
<!ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS!>abstract<!> val e3: Int = 0; get() = a
//methods
<!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>fun f()<!>
fun g() {}
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS!>abstract<!> fun h()
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int abstract get abstract set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var j: Int get() = i; abstract set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; abstract set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> abstract set
var k1: Int = 0; abstract set
var l: Int abstract get abstract set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var n: Int abstract get abstract set(v: Int) {}
}
compiler/testData/diagnostics/tests/AbstractInClass.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package abstract
class MyClass() {
compiler/testData/diagnostics/tests/AbstractInTrait.fir.kt
Vendored
-45
View File
@@ -1,45 +0,0 @@
package abstract
interface MyTrait {
//properties
val a: Int
val a1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>1<!>
abstract val a2: Int
abstract val a3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>1<!>
var b: Int <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
var b1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>; <!PRIVATE_SETTER_FOR_OPEN_PROPERTY!>private<!> set
abstract var b2: Int <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
abstract var b3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY!>private<!> set
<!BACKING_FIELD_IN_INTERFACE!>var c: Int<!> set(v: Int) { field = v }
<!BACKING_FIELD_IN_INTERFACE!>var c1: Int<!> = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>; set(v: Int) { field = v }
abstract var c2: Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
abstract var c3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_SETTER!>set(v: Int) { field = v }<!>
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>; get() = a
abstract val e2: Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
abstract val e3: Int = <!ABSTRACT_PROPERTY_WITH_INITIALIZER!>0<!>; <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = a<!>
//methods
fun f()
fun g() {}
abstract fun h()
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int abstract get abstract set
var i1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>; abstract get abstract set
var j: Int get() = i; abstract set
var j1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>; get() = i; abstract set
var k: Int abstract set
var k1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>; abstract set
var l: Int abstract get abstract set
var l1: Int = <!PROPERTY_INITIALIZER_IN_INTERFACE!>0<!>; abstract get abstract set
var n: Int abstract get abstract set(v: Int) {}
}
compiler/testData/diagnostics/tests/AbstractInTrait.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package abstract
interface MyTrait {
compiler/testData/diagnostics/tests/annotations/annotationModifier.fir.kt
Vendored
-15
View File
@@ -1,15 +0,0 @@
annotation class B
class A {
annotation companion object {}
}
annotation object O {}
annotation interface T {}
annotation fun f() = 0
annotation val x = 0
annotation var y = 0
compiler/testData/diagnostics/tests/annotations/annotationModifier.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
annotation class B
class A {
compiler/testData/diagnostics/tests/annotations/options/forParam.fir.kt
Vendored
+2 -2
View File
@@ -4,7 +4,7 @@
annotation class Ann
fun foo() {
for (@Ann private x in 1..100) {
for (@Ann <!WRONG_MODIFIER_TARGET!>private<!> x in 1..100) {
if (x == 1) return
}
}
}
compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.fir.kt
Vendored
-7
View File
@@ -1,7 +0,0 @@
@Target(AnnotationTarget.CLASS)
annotation class My
data class Pair(val a: Int, val b: Int)
fun foo(): Int {
val (<!WRONG_ANNOTATION_TARGET!>@My<!> private a, <!WRONG_ANNOTATION_TARGET!>@My<!> public b) = Pair(12, 34)
return a + b
}
compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
@Target(AnnotationTarget.CLASS)
annotation class My
data class Pair(val a: Int, val b: Int)
compiler/testData/diagnostics/tests/annotations/options/setterParam.fir.kt
Vendored
-8
View File
@@ -1,8 +0,0 @@
// KT-9145
@Target(AnnotationTarget.CLASS)
annotation class Ann
var x: Int
get() = 1
set(<!WRONG_ANNOTATION_TARGET!>@Ann<!> private x) { }
compiler/testData/diagnostics/tests/annotations/options/setterParam.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// KT-9145
@Target(AnnotationTarget.CLASS)
compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
// See EA-73584
data class<!SYNTAX!><!> {
}
// See KT-9296
data interface<!SYNTAX!><!> {
}
compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// See EA-73584
data class<!SYNTAX!><!> {
compiler/testData/diagnostics/tests/dataClasses/dataObject.fir.kt
Vendored
-1
View File
@@ -1 +0,0 @@
data object Object<!CONSTRUCTOR_IN_OBJECT!>(val x: Int, val y: Int)<!>
compiler/testData/diagnostics/tests/dataClasses/dataObject.kt
Vendored
+1
View File
@@ -1 +1,2 @@
// FIR_IDENTICAL
<!WRONG_MODIFIER_TARGET!>data<!> object Object<!CONSTRUCTOR_IN_OBJECT!>(val x: Int, val y: Int)<!>
compiler/testData/diagnostics/tests/dataClasses/strange.fir.kt
Vendored
+4 -4
View File
@@ -1,10 +1,10 @@
data enum class First(val x: Int) {
<!WRONG_MODIFIER_TARGET!>data<!> enum class First(val x: Int) {
A(1),
B(2)
}
data object Second
<!WRONG_MODIFIER_TARGET!>data<!> object Second
data interface Third
<!WRONG_MODIFIER_TARGET!>data<!> interface Third
data annotation class Fourth(val x: Int)
<!WRONG_MODIFIER_TARGET!>data<!> annotation class Fourth(val x: Int)
compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt
Vendored
+2 -2
View File
@@ -93,7 +93,7 @@ class Foo {
private val packagePrivateProperty = object : MyClass(), MyTrait {}
protected val packageProtectedProperty = object : MyClass(), MyTrait {}
<!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty = object : MyClass(), MyTrait {}
val packageInternalProperty = object : MyClass(), MyTrait {}
@@ -101,7 +101,7 @@ internal val packageInternal2Property = object : MyClass(), MyTrait {}
public val packagePublicProperty = object : MyClass(), MyTrait {}
protected fun packageProtectedFunction() = object : MyClass(), MyTrait {}
<!WRONG_MODIFIER_TARGET!>protected<!> fun packageProtectedFunction() = object : MyClass(), MyTrait {}
fun packageInternalFunction() = object : MyClass(), MyTrait {}
compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.fir.kt
Vendored
-19
View File
@@ -1,19 +0,0 @@
// !DIAGNOSTICS: -MANY_COMPANION_OBJECTS -REDECLARATION -DUPLICATE_CLASS_NAMES
// KT-3464 Front-end shouldn't allow override modifier in class declaration
override class A {
override companion object {}
open companion object {}
abstract companion object {}
final companion object {}
}
override object B1 {}
open object B2 {}
abstract object B3 {}
final object B4 {}
override enum class C {}
override interface D {}
override annotation class E
compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -MANY_COMPANION_OBJECTS -REDECLARATION -DUPLICATE_CLASS_NAMES
// KT-3464 Front-end shouldn't allow override modifier in class declaration
compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.fir.kt
Vendored
+4 -4
View File
@@ -5,8 +5,8 @@ class T {
}
fun foo() {
public val i = 11
abstract val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>j<!>
override fun T.baz() = 2
private fun bar() = 2
<!WRONG_MODIFIER_TARGET!>public<!> val i = 11
<!WRONG_MODIFIER_TARGET!>abstract<!> val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>j<!>
<!WRONG_MODIFIER_TARGET!>override<!> fun T.baz() = 2
<!WRONG_MODIFIER_TARGET!>private<!> fun bar() = 2
}
compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.fir.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@ class T {
fun baz() = 1
}
override fun zzz() {}
<!WRONG_MODIFIER_TARGET!>override<!> fun zzz() {}
fun foo(t: T) {
override fun T.baz() = 2
<!WRONG_MODIFIER_TARGET!>override<!> fun T.baz() = 2
// was "Visibility is unknown yet exception"
t.baz()
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ fun test() {
val <T> a0 = 0
val <T : __UNRESOLVED__> a1 = ""
val <T : String> a2 = 0
const val <T> a3 = 0
<!WRONG_MODIFIER_TARGET!>const<!> val <T> a3 = 0
<!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
val <T> a5 by Delegate<Int>()
val <T> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ fun test() {
val <T> a0 = 0
val <T : __UNRESOLVED__> a1 = ""
val <T : String> a2 = 0
const val <T> a3 = 0
<!WRONG_MODIFIER_TARGET!>const<!> val <T> a3 = 0
<!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
val <T> a5 by Delegate<Int>()
val <T> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.fir.kt
Vendored
-12
View File
@@ -1,12 +0,0 @@
package d
abstract val a : Int = 1
override val c : Int = 1
final fun foo() = 2
abstract fun baz() = 2
class T {}
override fun T.bar() = 2
compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package d
<!WRONG_MODIFIER_TARGET!>abstract<!> val a : Int = 1
compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.fir.kt
Vendored
+2 -2
View File
@@ -1,10 +1,10 @@
package d
override val f : ()-> Int = { 12 }
<!WRONG_MODIFIER_TARGET!>override<!> val f : ()-> Int = { 12 }
fun test() {
f()
}
var g: Int = 1
protected set(i: Int) {}
protected set(i: Int) {}
compiler/testData/diagnostics/tests/declarationChecks/sealedOnMembers.fir.kt
Vendored
-18
View File
@@ -1,18 +0,0 @@
interface A {
sealed fun foo()
sealed var bar: Unit
}
interface B {
abstract fun foo()
abstract var bar: Unit
}
interface C : A, B
abstract class D(sealed var x: Int) {
abstract var y: Unit
sealed set
}
abstract class E : D(42)
compiler/testData/diagnostics/tests/declarationChecks/sealedOnMembers.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
interface A {
<!WRONG_MODIFIER_TARGET!>sealed<!> fun foo()
<!WRONG_MODIFIER_TARGET!>sealed<!> var bar: Unit
compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.fir.kt
Vendored
-175
View File
@@ -1,175 +0,0 @@
open class MyClass {
fun f1() {}
}
class Foo {
protected val protectedProperty = object : MyClass() {}
public val publicProperty = object : MyClass() {}
protected val protected2Property : MyClass = object : MyClass() {fun invisible() {}}
public val public2Property : MyClass = object : MyClass() {fun invisible() {}}
private val privateProperty = object : MyClass() {fun visible() {}}
internal val internalProperty = object : MyClass() { fun invisible() {}}
fun testProperties() {
privateProperty.f1()
internalProperty.f1()
protected2Property.f1()
public2Property.f1()
privateProperty.visible()
protected2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
public2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
internalProperty.<!UNRESOLVED_REFERENCE!>invisible<!>()
}
protected fun protectedFunction() = object : MyClass() {}
public fun publicFunction() = object : MyClass() {}
protected fun protected2Function(): MyClass = object : MyClass() {fun visible() {}}
public fun public2Function(): MyClass = object : MyClass() {fun visible() {}}
private fun privateFunction() = object : MyClass() {fun visible() {}}
internal fun internalFunction() = object : MyClass() {fun invisible() {}}
fun testFunctions() {
privateFunction().f1()
internalFunction().f1()
public2Function().f1()
protected2Function().f1()
privateFunction().visible()
internalFunction().<!UNRESOLVED_REFERENCE!>invisible<!>()
public2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
protected2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
}
class FooInner {
public val publicProperty = object : MyClass() {}
protected val protectedProperty = object : MyClass() {}
protected val protected2Property : MyClass = object : MyClass() {fun invisible() {}}
public val public2Property : MyClass = object : MyClass() {fun invisible() {}}
private val privateProperty = object : MyClass() {fun visible() {}}
internal val internalProperty = object : MyClass() { fun invisible() {}}
fun testProperties() {
privateProperty.f1()
internalProperty.f1()
protected2Property.f1()
public2Property.f1()
privateProperty.visible()
protected2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
public2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
internalProperty.<!UNRESOLVED_REFERENCE!>invisible<!>()
}
protected fun protectedFunction() = object : MyClass() {}
public fun publicFunction() = object : MyClass() {}
protected fun protected2Function(): MyClass = object : MyClass() {fun visible() {}}
public fun public2Function(): MyClass = object : MyClass() {fun visible() {}}
private fun privateFunction() = object : MyClass() {fun visible() {}}
internal fun internalFunction() = object : MyClass() {fun invisible() {}}
fun testFunctions() {
privateFunction().f1()
internalFunction().f1()
public2Function().f1()
protected2Function().f1()
privateFunction().visible()
internalFunction().<!UNRESOLVED_REFERENCE!>invisible<!>()
public2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
protected2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
}
}
fun foo() {
val localVar = object : MyClass() {}
localVar.f1()
fun foo2() = object : MyClass() {}
foo2().f1()
}
}
protected val packageProtectedProperty = object : MyClass() {}
public val packagePublicProperty = object : MyClass() {}
public val packagePublic2Property : MyClass = object : MyClass() {fun invisible() {}}
private val packagePrivateProperty = object : MyClass() {fun invisible() {}}
internal val packageInternalProperty = object : MyClass() {fun invisible() {}}
fun testProperties() {
packagePrivateProperty.f1()
packageInternalProperty.f1()
packagePublic2Property.f1()
packagePrivateProperty.invisible()
packageInternalProperty.<!UNRESOLVED_REFERENCE!>invisible<!>()
packagePublic2Property.<!UNRESOLVED_REFERENCE!>invisible<!>()
}
private fun privateFunction() = object : MyClass() {fun invisible() {}}
protected fun protectedFunction() = object : MyClass() {}
public fun publicFunction() = object : MyClass() {}
public fun public2Function() : MyClass = object : MyClass() {fun invisible() {}}
internal fun internalFunction() = object : MyClass() {fun invisible() {}}
fun testFunctions() {
privateFunction().f1()
internalFunction().f1()
public2Function().f1()
privateFunction().invisible()
internalFunction().<!UNRESOLVED_REFERENCE!>invisible<!>()
public2Function().<!UNRESOLVED_REFERENCE!>invisible<!>()
}
fun fooPackage() {
val packageLocalVar = object : MyClass() {fun visible() {}}
packageLocalVar.f1()
packageLocalVar.visible()
fun fooPackageLocal() = object : MyClass() {fun visible() {}}
fooPackageLocal().f1()
fooPackageLocal().visible()
}
compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
open class MyClass {
fun f1() {}
}
compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.fir.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ interface T {}
class Br(t : T) : T by t {}
open enum class EN() {
<!WRONG_MODIFIER_TARGET!>open<!> enum class EN() {
A
}
compiler/testData/diagnostics/tests/enum/AbstractEnum.fir.kt
Vendored
-3
View File
@@ -1,3 +0,0 @@
package abstract
abstract enum class MyAbstractEnum() {}
compiler/testData/diagnostics/tests/enum/AbstractEnum.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package abstract
<!WRONG_MODIFIER_TARGET!>abstract<!> enum class MyAbstractEnum() {}
compiler/testData/diagnostics/tests/enum/AbstractInEnum.fir.kt
Vendored
+9 -9
View File
@@ -31,17 +31,17 @@ enum class MyEnum() {
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int abstract get abstract set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var i: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j: Int get() = i; abstract set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; abstract set
var j: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> abstract set
var k1: Int = 0; abstract set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k1: Int = 0; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l: Int abstract get abstract set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; abstract get abstract set
var l: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var n: Int abstract get abstract set(v: Int) {}
var n: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
}
compiler/testData/diagnostics/tests/enum/enumModifier.fir.kt
Vendored
-15
View File
@@ -1,15 +0,0 @@
enum class B {}
class A {
enum companion object {}
}
enum object O {}
enum interface T {}
enum fun f() = 0
enum val x = 0
enum var y = 0
compiler/testData/diagnostics/tests/enum/enumModifier.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
enum class B {}
class A {
compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.fir.kt
Vendored
-3
View File
@@ -1,3 +0,0 @@
annotation enum class E {
D
}
compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
<!WRONG_MODIFIER_TARGET!>annotation<!> enum class E {
D
}
compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
public enum MyJavaEnum {}
// FILE: test.kt
open enum class MyEnum() {
<!WRONG_MODIFIER_TARGET!>open<!> enum class MyEnum() {
A()
}
compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_after.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
enum class E {
ABC {
enum class F {
<!WRONG_MODIFIER_TARGET!>enum<!> class F {
DEF
}
}
compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_before.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
enum class E {
ABC {
enum class F {
<!WRONG_MODIFIER_TARGET!>enum<!> class F {
DEF
}
}
compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.fir.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
enum interface Some {
<!WRONG_MODIFIER_TARGET!>enum<!> interface Some {
// Enum part
D;
// Interface like part
fun test()
val foo: Int
}
}
compiler/testData/diagnostics/tests/enum/localEnums.fir.kt
Vendored
+5 -5
View File
@@ -1,20 +1,20 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
fun foo() {
enum class A {
<!WRONG_MODIFIER_TARGET!>enum<!> class A {
FOO,
BAR
}
val foo = A.FOO
val b = object {
enum class B {}
<!WRONG_MODIFIER_TARGET!>enum<!> class B {}
}
class C {
enum class D {}
<!WRONG_MODIFIER_TARGET!>enum<!> class D {}
}
val f = {
enum class E {}
<!WRONG_MODIFIER_TARGET!>enum<!> class E {}
}
enum class<!SYNTAX!><!> {}
<!WRONG_MODIFIER_TARGET!>enum<!> class<!SYNTAX!><!> {}
}
compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.fir.kt
Vendored
-23
View File
@@ -1,23 +0,0 @@
enum class E {
public final SUBCLASS {
fun foo() {}
},
public PUBLIC,
protected PROTECTED,
private PRIVATE,
internal INTERNAL,
abstract ABSTRACT,
open OPEN,
override OVERRIDE,
final FINAL,
inner INNER,
annotation ANNOTATION,
enum ENUM,
out OUT,
in IN,
vararg VARARG,
reified REIFIED
}
compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
enum class E {
<!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>final<!> SUBCLASS {
fun foo() {}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/modifiers.fir.kt
Vendored
-15
View File
@@ -1,15 +0,0 @@
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_PARAMETER
data class A(val x: Int, val y: String)
fun foo(block: (A) -> Unit) { }
@Target(AnnotationTarget.VALUE_PARAMETER)
annotation class Ann
fun bar() {
foo { (private inline a, <!WRONG_ANNOTATION_TARGET!>@Ann<!> b) ->
a checkType { _<Int>() }
b checkType { _<String>() }
}
}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/modifiers.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_PARAMETER
data class A(val x: Int, val y: String)
compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.fir.kt
Vendored
-59
View File
@@ -1,59 +0,0 @@
abstract class Test() {
abstract val x : Int
abstract val x1 : Int get
abstract val x2 : Int <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val a : Int<!>
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val b : Int<!> get
val c = 1
val c1 = 1
get
val c2 : Int
get() = 1
val c3 : Int
get() { return 1 }
val c4 : Int
get() = 1
<!MUST_BE_INITIALIZED!>val c5 : Int<!>
get() = field + 1
abstract var y : Int
abstract var y1 : Int get
abstract var y2 : Int set
abstract var y3 : Int set get
abstract var y4 : Int set <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
abstract var y5 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!> <!ABSTRACT_PROPERTY_WITH_GETTER!>get() = 1<!>
abstract var y6 : Int <!ABSTRACT_PROPERTY_WITH_SETTER!>set(x) {}<!>
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v : Int<!>
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v1 : Int<!> get
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v2 : Int<!> get set
<!MUST_BE_INITIALIZED!>var v3 : Int<!> get() = 1; set
var v4 : Int get() = 1; set(x){}
<!MUST_BE_INITIALIZED!>var v5 : Int<!> get() = 1; set(x){field = x}
<!MUST_BE_INITIALIZED!>var v6 : Int<!> get() = field + 1; set(x){}
abstract val v7 : Int get
abstract var v8 : Int get set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v9 : Int<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v10 : Int<!> get
abstract val v11 : Int abstract get
abstract var v12 : Int abstract get abstract set
}
open class Super(i : Int)
class TestPCParameters(w : Int, x : Int, val y : Int, var z : Int) : Super(w) {
val xx = w
init {
w + 1
}
fun foo() = <!UNRESOLVED_REFERENCE!>x<!>
}
compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
abstract class Test() {
abstract val x : Int
abstract val x1 : Int get
compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.fir.kt
Vendored
-8
View File
@@ -1,8 +0,0 @@
// !LANGUAGE: +InlineClasses, -JvmInlineValueClasses
inline class Foo(val x: Int)
inline interface InlineInterface
inline annotation class InlineAnn
inline object InlineObject
inline enum class InlineEnum
compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +InlineClasses, -JvmInlineValueClasses
inline class Foo(val x: Int)
compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.fir.kt
Vendored
+3 -3
View File
@@ -3,8 +3,8 @@
inline class Foo(val x: Int)
inline annotation class InlineAnn
inline object InlineObject
inline enum class InlineEnum
<!WRONG_MODIFIER_TARGET!>inline<!> annotation class InlineAnn
<!WRONG_MODIFIER_TARGET!>inline<!> object InlineObject
<!WRONG_MODIFIER_TARGET!>inline<!> enum class InlineEnum
inline class NotVal(<!INLINE_CLASS_CONSTRUCTOR_NOT_FINAL_READ_ONLY_PARAMETER!>x: Int<!>)
compiler/testData/diagnostics/tests/inlineClasses/inlineClassDeclarationCheck.fir.kt
Vendored
+1 -1
View File
@@ -29,7 +29,7 @@ object B2 {
}
fun foo() {
<!INLINE_CLASS_NOT_TOP_LEVEL!>inline<!> class C4(val x: Int)
<!INLINE_CLASS_NOT_TOP_LEVEL, WRONG_MODIFIER_TARGET!>inline<!> class C4(val x: Int)
}
final inline class D0(val x: Int)
compiler/testData/diagnostics/tests/inlineClasses/innerClassInsideInlineClass.fir.kt
Vendored
+2 -2
View File
@@ -3,6 +3,6 @@
inline class Foo(val x: Int) {
<!INNER_CLASS_INSIDE_INLINE_CLASS!>inner<!> class InnerC
<!INNER_CLASS_INSIDE_INLINE_CLASS!>inner<!> object InnerO
<!INNER_CLASS_INSIDE_INLINE_CLASS!>inner<!> interface InnerI
<!INNER_CLASS_INSIDE_INLINE_CLASS, WRONG_MODIFIER_TARGET!>inner<!> object InnerO
<!INNER_CLASS_INSIDE_INLINE_CLASS, WRONG_MODIFIER_TARGET!>inner<!> interface InnerI
}
compiler/testData/diagnostics/tests/inner/illegalModifier.fir.kt
Vendored
-45
View File
@@ -1,45 +0,0 @@
// !LANGUAGE: -InnerClassInEnumEntryClass
inner fun foo() {}
inner val prop = 42
inner class A
inner interface B
inner object C
class D {
inner class E
inner interface F
inner object G
inner enum class R
inner annotation class S
inner companion object
}
enum class H {
I0 {
inner class II0
},
inner I {
inner class II
};
inner class J
}
interface K {
inner class L
}
object N {
inner class O
}
class P {
companion object {
inner class Q
}
}
val R = object {
inner class S
}
compiler/testData/diagnostics/tests/inner/illegalModifier.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: -InnerClassInEnumEntryClass
<!WRONG_MODIFIER_TARGET!>inner<!> fun foo() {}
<!WRONG_MODIFIER_TARGET!>inner<!> val prop = 42
compiler/testData/diagnostics/tests/inner/illegalModifier_lv12.fir.kt
Vendored
-45
View File
@@ -1,45 +0,0 @@
// !LANGUAGE: +InnerClassInEnumEntryClass
inner fun foo() {}
inner val prop = 42
inner class A
inner interface B
inner object C
class D {
inner class E
inner interface F
inner object G
inner enum class R
inner annotation class S
inner companion object
}
enum class H {
I0 {
inner class II0
},
inner I {
inner class II
};
inner class J
}
interface K {
inner class L
}
object N {
inner class O
}
class P {
companion object {
inner class Q
}
}
val R = object {
inner class S
}
compiler/testData/diagnostics/tests/inner/illegalModifier_lv12.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +InnerClassInEnumEntryClass
<!WRONG_MODIFIER_TARGET!>inner<!> fun foo() {}
<!WRONG_MODIFIER_TARGET!>inner<!> val prop = 42
compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv11.fir.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ enum class Enum {
<!LOCAL_OBJECT_NOT_ALLOWED!>object TestObject<!>
enum class TestEnumClass {
<!WRONG_MODIFIER_TARGET!>enum<!> class TestEnumClass {
OTHER_ENTRY
}
compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv12.fir.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ enum class Enum {
<!LOCAL_OBJECT_NOT_ALLOWED!>object TestObject<!>
enum class TestEnumClass {
<!WRONG_MODIFIER_TARGET!>enum<!> class TestEnumClass {
OTHER_ENTRY
}
compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv13.fir.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ enum class Enum {
<!LOCAL_OBJECT_NOT_ALLOWED!>object TestObject<!>
enum class TestEnumClass {
<!WRONG_MODIFIER_TARGET!>enum<!> class TestEnumClass {
OTHER_ENTRY
}
compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt
Vendored
+62 -62
View File
@@ -8,17 +8,17 @@ abstract class A() {
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>open var r: String<!>
get
abstract protected set
<!WRONG_MODIFIER_TARGET!>abstract<!> protected set
}
final interface T {}
<!WRONG_MODIFIER_TARGET!>final<!> interface T {}
class FinalClass() {
<!NON_FINAL_MEMBER_IN_FINAL_CLASS!>open<!> fun foo() {}
val i: Int = 1
open get(): Int = field
<!WRONG_MODIFIER_TARGET!>open<!> get(): Int = field
var j: Int = 1
open set(v: Int) {}
<!WRONG_MODIFIER_TARGET!>open<!> set(v: Int) {}
}
<!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>public<!> class C
@@ -32,107 +32,107 @@ class LegalModifier(val a: Int, @annotated private var b: String, @annotated var
//Check illegal modifier in constructor parameters
class IllegalModifiers1(
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!WRONG_MODIFIER_TARGET!>in<!>
<!INCOMPATIBLE_MODIFIERS!>out<!>
reified
enum
private
const
<!WRONG_MODIFIER_TARGET!>reified<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!WRONG_MODIFIER_TARGET!>private<!>
<!WRONG_MODIFIER_TARGET!>const<!>
a: Int)
//Check multiple illegal modifiers in constructor
class IllegalModifiers2(<!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> a: Int)
class IllegalModifiers2(<!WRONG_MODIFIER_TARGET!>private<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> a: Int)
//Check annotations with illegal modifiers in constructor
class IllegalModifiers3(@annotated public abstract b: String)
class IllegalModifiers3(@annotated <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> b: String)
//Check annotations and vararg with illegal modifiers in constructor
class IllegalModifiers4(val a: Int, @annotated("a text") protected vararg v: Int)
class IllegalModifiers4(val a: Int, @annotated("a text") <!WRONG_MODIFIER_TARGET!>protected<!> vararg v: Int)
//Check illegal modifiers for functions and catch block
abstract class IllegalModifiers5() {
//Check illegal modifier in function parameter
abstract fun foo(public a: Int, vararg v: String)
abstract fun foo(<!WRONG_MODIFIER_TARGET!>public<!> a: Int, vararg v: String)
//Check multiple illegal modifiers in function parameter
abstract fun bar(public abstract a: Int, vararg v: String)
abstract fun bar(<!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> a: Int, vararg v: String)
//Check annotations with illegal modifiers
abstract fun baz(@annotated("a text") public abstract a: Int)
abstract fun baz(@annotated("a text") <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> a: Int)
private fun qux() {
//Check illegal modifier in catch block
try {} catch (<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> reified enum public e: Exception) {}
try {} catch (<!WRONG_MODIFIER_TARGET!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> <!WRONG_MODIFIER_TARGET!>reified<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
//Check multiple illegal modifiers in catch block
try {} catch (<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> reified enum abstract public e: Exception) {}
try {} catch (<!WRONG_MODIFIER_TARGET!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> <!WRONG_MODIFIER_TARGET!>reified<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!WRONG_MODIFIER_TARGET!>abstract<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
//Check annotations with illegal modifiers
try {} catch (@annotated("a text") abstract public e: Exception) {}
try {} catch (@annotated("a text") <!WRONG_MODIFIER_TARGET!>abstract<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
}
}
//Check illegal modifiers on anonymous initializers
abstract class IllegalModifiers6() {
public init {}
private init {}
protected init {}
vararg init {}
abstract init {}
open init {}
final init {}
<!WRONG_MODIFIER_TARGET!>public<!> init {}
<!WRONG_MODIFIER_TARGET!>private<!> init {}
<!WRONG_MODIFIER_TARGET!>protected<!> init {}
<!WRONG_MODIFIER_TARGET!>vararg<!> init {}
<!WRONG_MODIFIER_TARGET!>abstract<!> init {}
<!WRONG_MODIFIER_TARGET!>open<!> init {}
<!WRONG_MODIFIER_TARGET!>final<!> init {}
public @annotated init {}
<!WRONG_MODIFIER_TARGET!>public<!> @annotated init {}
private @IllegalModifiers6() init {}
<!WRONG_MODIFIER_TARGET!>private<!> @IllegalModifiers6() init {}
}
// strange inappropriate modifiers usages
override
<!INCOMPATIBLE_MODIFIERS!>out<!>
<!WRONG_MODIFIER_TARGET!>override<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
vararg
reified
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
class IllegalModifiers7() {
enum
inner
annotation
<!INCOMPATIBLE_MODIFIERS!>out<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_MODIFIER_TARGET!>annotation<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
vararg
reified
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
val x = 1
enum
inner
annotation
<!INCOMPATIBLE_MODIFIERS!>out<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_MODIFIER_TARGET!>annotation<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
vararg
reified
const
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
<!WRONG_MODIFIER_TARGET!>const<!>
fun foo() {}
}
// Secondary constructors
class IllegalModifiers8 {
<!INCOMPATIBLE_MODIFIERS!>abstract<!>
<!WRONG_MODIFIER_TARGET!>abstract<!>
enum
<!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>open<!>
inner
annotation
<!INCOMPATIBLE_MODIFIERS!>override<!>
<!INCOMPATIBLE_MODIFIERS!>out<!>
<!REDUNDANT_MODIFIER, WRONG_MODIFIER_TARGET!>open<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_MODIFIER_TARGET!>annotation<!>
<!WRONG_MODIFIER_TARGET!>override<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!INCOMPATIBLE_MODIFIERS!>final<!>
vararg
reified
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
<!INCOMPATIBLE_MODIFIERS!>const<!><!SYNTAX!><!>
constructor() {}
constructor(<!INCOMPATIBLE_MODIFIERS!>private<!> enum <!INCOMPATIBLE_MODIFIERS!>abstract<!> x: Int) {}
constructor(<!WRONG_MODIFIER_TARGET!>private<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!INCOMPATIBLE_MODIFIERS!>abstract<!> x: Int) {}
}
class IllegalModifiers9 {
@@ -143,17 +143,17 @@ class IllegalModifiers9 {
// Illegal modifiers on primary constructor
class IllegalModifiers10
<!INCOMPATIBLE_MODIFIERS!>abstract<!>
enum
<!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>open<!>
inner
annotation
<!INCOMPATIBLE_MODIFIERS!>override<!>
<!INCOMPATIBLE_MODIFIERS!>out<!>
<!WRONG_MODIFIER_TARGET!>abstract<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!REDUNDANT_MODIFIER, WRONG_MODIFIER_TARGET!>open<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_MODIFIER_TARGET!>annotation<!>
<!WRONG_MODIFIER_TARGET!>override<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!INCOMPATIBLE_MODIFIERS!>final<!>
vararg
reified
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
<!INCOMPATIBLE_MODIFIERS!>const<!> constructor()
class IllegalModifiers11 <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>protected<!> constructor()
compiler/testData/diagnostics/tests/modifiers/NoLocalVisibility.fir.kt
Vendored
-6
View File
@@ -1,6 +0,0 @@
fun foo() {
public class A
private class B
protected class C
internal class D
}
compiler/testData/diagnostics/tests/modifiers/NoLocalVisibility.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
fun foo() {
<!WRONG_MODIFIER_TARGET!>public<!> class A
<!WRONG_MODIFIER_TARGET!>private<!> class B
compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt
Vendored
+1 -1
View File
@@ -48,7 +48,7 @@ const val withExplicitDefaultGetter: Int = 1
<!CONST_VAL_WITH_GETTER!>get<!>
fun foo(): Int {
const val local: Int = 14
<!WRONG_MODIFIER_TARGET!>const<!> val local: Int = 14
return 15
}
compiler/testData/diagnostics/tests/modifiers/defaultModifier.fir.kt
Vendored
-55
View File
@@ -1,55 +0,0 @@
companion class A {
companion object {
}
}
class B {
companion object
val c: Int = 1
}
class C {
companion object A {
}
}
class D {
companion object A {
companion object {
}
}
}
companion object G {
companion object
}
companion interface H {
companion object
}
class J {
companion object C {
companion object
}
}
companion enum class Enum {
E1,
E2;
companion object
}
companion fun main() {
}
companion var prop: Int = 1
companion get
companion set
class Z(companion val c: Int)
compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
<!WRONG_MODIFIER_TARGET!>companion<!> class A {
companion object {
compiler/testData/diagnostics/tests/modifiers/modifierOnParameterInFunctionType.fir.kt
Vendored
+12 -12
View File
@@ -19,34 +19,34 @@ class A : (vararg Int)->Unit {
get(): (vararg x: Int)->Unit = {}
}
val allProhibited: (<!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>abstract<!>
annotation
companion
val allProhibited: (<!REDUNDANT_MODIFIER, WRONG_MODIFIER_TARGET!>abstract<!>
<!WRONG_MODIFIER_TARGET!>annotation<!>
<!WRONG_MODIFIER_TARGET!>companion<!>
<!INCOMPATIBLE_MODIFIERS!>const<!>
<!INCOMPATIBLE_MODIFIERS!>crossinline<!>
<!INCOMPATIBLE_MODIFIERS!>data<!>
enum
external
<!WRONG_MODIFIER_TARGET!>enum<!>
<!WRONG_MODIFIER_TARGET!>external<!>
<!INCOMPATIBLE_MODIFIERS!>final<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!WRONG_MODIFIER_TARGET!>in<!>
<!INCOMPATIBLE_MODIFIERS!>inline<!>
<!INCOMPATIBLE_MODIFIERS!>inner<!>
<!INCOMPATIBLE_MODIFIERS!>internal<!>
lateinit
<!WRONG_MODIFIER_TARGET!>internal<!>
<!WRONG_MODIFIER_TARGET!>lateinit<!>
<!INCOMPATIBLE_MODIFIERS!>noinline<!>
<!INCOMPATIBLE_MODIFIERS, REDUNDANT_MODIFIER!>open<!>
operator
<!WRONG_MODIFIER_TARGET!>operator<!>
<!INCOMPATIBLE_MODIFIERS!>out<!>
<!INCOMPATIBLE_MODIFIERS!>override<!>
<!INCOMPATIBLE_MODIFIERS!>private<!>
<!INCOMPATIBLE_MODIFIERS!>protected<!>
<!INCOMPATIBLE_MODIFIERS!>public<!>
reified
<!WRONG_MODIFIER_TARGET!>reified<!>
<!INCOMPATIBLE_MODIFIERS!>sealed<!>
tailrec
<!WRONG_MODIFIER_TARGET!>tailrec<!>
vararg
x: Int)->Unit = {}
val valProhibited: (val x: Int)->Unit = {}
val varProhibited: (var x: Int)->Unit = {}
val varProhibited: (var x: Int)->Unit = {}
compiler/testData/diagnostics/tests/modifiers/redundantTargets.fir.kt
Vendored
-10
View File
@@ -1,10 +0,0 @@
open interface First
// Now inspection
abstract interface Second
// Now inspection
final enum class Third {
FOURTH,
FIFTH
}
// Now inspection
final object Sixth
compiler/testData/diagnostics/tests/modifiers/redundantTargets.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
<!REDUNDANT_MODIFIER_FOR_TARGET!>open<!> interface First
// Now inspection
abstract interface Second
compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.fir.kt
Vendored
+2 -2
View File
@@ -11,7 +11,7 @@ class Bzz(public <!REPEATED_MODIFIER!>public<!> val q: Int = 1) {
public <!REPEATED_MODIFIER!>public<!> get() = 3
val z: Int
<!INCOMPATIBLE_MODIFIERS!>open<!> <!INCOMPATIBLE_MODIFIERS!>final<!> get() = 4
<!WRONG_MODIFIER_TARGET!>open<!> <!INCOMPATIBLE_MODIFIERS!>final<!> get() = 4
public <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
public <!REPEATED_MODIFIER!>public<!> val y: Int = 2
@@ -31,7 +31,7 @@ public <!REPEATED_MODIFIER!>public<!> val bar: Int = 1
public <!REPEATED_MODIFIER!>public<!> fun foo(): Int = 1
fun test() {
public <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
<!WRONG_MODIFIER_TARGET!>public<!> <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
public <!REPEATED_MODIFIER!>public<!> val y: Int = 2
public val x: Int
compiler/testData/diagnostics/tests/multiplatform/deprecated/header.fir.kt
Vendored
+10 -10
View File
@@ -2,29 +2,29 @@
// MODULE: m1-common
// FILE: common.kt
header class My
<!DEPRECATED_MODIFIER!>header<!> class My
header fun foo(): Int
<!DEPRECATED_MODIFIER!>header<!> fun foo(): Int
header val x: String
<!DEPRECATED_MODIFIER!>header<!> val x: String
header object O
<!DEPRECATED_MODIFIER!>header<!> object O
header enum class E {
<!DEPRECATED_MODIFIER!>header<!> enum class E {
FIRST
}
// MODULE: m2-jvm()()(m1-common)
// FILE: jvm.kt
impl class My
<!DEPRECATED_MODIFIER!>impl<!> class My
impl fun foo() = 42
<!DEPRECATED_MODIFIER!>impl<!> fun foo() = 42
impl val x get() = "Hello"
<!DEPRECATED_MODIFIER!>impl<!> val x get() = "Hello"
impl object O
<!DEPRECATED_MODIFIER!>impl<!> object O
impl enum class E {
<!DEPRECATED_MODIFIER!>impl<!> enum class E {
FIRST
}
compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
// FILE: common.kt
expect class H {
expect fun foo()
<!WRONG_MODIFIER_TARGET!>expect<!> fun foo()
}
// MODULE: m1-jvm()()(m1-common)
compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.fir.kt
Vendored
+4 -4
View File
@@ -5,14 +5,14 @@
expect class B {
class N {
<!EXPECTED_DECLARATION_WITH_BODY!>fun body()<!> {}
expect fun extraHeader()
<!WRONG_MODIFIER_TARGET!>expect<!> fun extraHeader()
}
}
expect class C {
expect class N
expect enum class E
expect inner class I
<!WRONG_MODIFIER_TARGET!>expect<!> class N
<!WRONG_MODIFIER_TARGET!>expect<!> enum class E
<!WRONG_MODIFIER_TARGET!>expect<!> inner class I
}
expect class D {
compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
// FILE: common.kt
class Foo {
<!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>expect fun bar(): String<!>
<!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!><!WRONG_MODIFIER_TARGET!>expect<!> fun bar(): String<!>
}
// MODULE: m1-jvm()()(m1-common)
compiler/testData/diagnostics/tests/multiplatform/incompatibles.fir.kt
Vendored
+6 -6
View File
@@ -1,13 +1,13 @@
// !LANGUAGE: +MultiPlatformProjects
<!INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class First
<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>impl<!> class First
<!INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second
<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Second
<!INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Third
<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>header<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Third
<!INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Fourth
<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>expect<!> class Fourth
<!INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Fifth
<!DEPRECATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>impl<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Fifth
<!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Sixth
<!INCOMPATIBLE_MODIFIERS!>expect<!> <!INCOMPATIBLE_MODIFIERS!>actual<!> class Sixth
compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.fir.kt
Vendored
+13 -13
View File
@@ -2,21 +2,21 @@
// MODULE: m1-common
// FILE: common.kt
expect typealias Foo = String
<!WRONG_MODIFIER_TARGET!>expect<!> typealias Foo = String
class Outer expect constructor() {
expect class Nested
class Outer <!WRONG_MODIFIER_TARGET!>expect<!> constructor() {
<!WRONG_MODIFIER_TARGET!>expect<!> class Nested
expect init {}
<!WRONG_MODIFIER_TARGET!>expect<!> init {}
<!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!>expect fun foo()<!>
expect val bar: Int
<!NON_ABSTRACT_FUNCTION_WITH_NO_BODY!><!WRONG_MODIFIER_TARGET!>expect<!> fun foo()<!>
<!WRONG_MODIFIER_TARGET!>expect<!> val bar: Int
}
fun foo() {
expect fun localFun()
expect var x = 42
expect class Bar
<!WRONG_MODIFIER_TARGET!>expect<!> fun localFun()
<!WRONG_MODIFIER_TARGET!>expect<!> var x = 42
<!WRONG_MODIFIER_TARGET!>expect<!> class Bar
}
// MODULE: m2-jvm
@@ -25,11 +25,11 @@ fun foo() {
class Outer <!ACTUAL_WITHOUT_EXPECT!>actual constructor()<!> {
actual class Nested
actual init {}
<!WRONG_MODIFIER_TARGET!>actual<!> init {}
}
fun foo() {
actual fun localFun() {}
actual var x = 42
actual class Bar
<!WRONG_MODIFIER_TARGET!>actual<!> fun localFun() {}
<!WRONG_MODIFIER_TARGET!>actual<!> var x = 42
<!WRONG_MODIFIER_TARGET!>actual<!> class Bar
}
compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.fir.kt
Vendored
+3 -3
View File
@@ -14,8 +14,8 @@ expect var varWithGetSet: String
get set
expect var varWithPlatformGetSet: String
expect get
expect set
<!WRONG_MODIFIER_TARGET!>expect<!> get
<!WRONG_MODIFIER_TARGET!>expect<!> set
expect val backingFieldVal: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
expect var backingFieldVar: String = <!EXPECTED_PROPERTY_INITIALIZER!>"no"<!>
@@ -34,7 +34,7 @@ expect val delegated: String by <!EXPECTED_DELEGATED_PROPERTY!>Delegate<!>
object Delegate { operator fun getValue(x: Any?, y: Any?): String = "" }
fun test(): String {
expect val localVariable: String
<!WRONG_MODIFIER_TARGET!>expect<!> val localVariable: String
localVariable = "no"
return localVariable
}
compiler/testData/diagnostics/tests/properties/abstarctPropertyInPrimaryConstructor.fir.kt
Vendored
-2
View File
@@ -1,2 +0,0 @@
class A(<!ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS!>abstract<!> val i: Int)
class B(abstract i: Int)
compiler/testData/diagnostics/tests/properties/abstarctPropertyInPrimaryConstructor.kt
Vendored
+1
View File
@@ -1,2 +1,3 @@
// FIR_IDENTICAL
class A(<!ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS!>abstract<!> val i: Int)
class B(<!WRONG_MODIFIER_TARGET!>abstract<!> i: Int)
compiler/testData/diagnostics/tests/regressions/kt9384.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
fun main(args: Array<String>) {
fun f() = run {
private class C {
<!WRONG_MODIFIER_TARGET!>private<!> class C {
private fun foo() {
f().<!UNRESOLVED_REFERENCE!>foo<!>();
compiler/testData/diagnostics/tests/scopes/visibility.fir.kt
Vendored
+2 -2
View File
@@ -6,8 +6,8 @@ package test_visibility
protected class ProtectedClass
protected interface ProtectedTrait
protected val protected_val : Int = 4
protected fun protected_fun() {}
<!WRONG_MODIFIER_TARGET!>protected<!> val protected_val : Int = 4
<!WRONG_MODIFIER_TARGET!>protected<!> fun protected_fun() {}
private val private_val : Int = 4
private fun private_fun() {}
compiler/testData/diagnostics/tests/sealed/LocalSealed.fir.kt
Vendored
-3
View File
@@ -1,3 +0,0 @@
fun foo() {
sealed class My
}
compiler/testData/diagnostics/tests/sealed/LocalSealed.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
fun foo() {
<!WRONG_MODIFIER_TARGET!>sealed<!> class My
}
compiler/testData/diagnostics/tests/sealed/NeverEnum.fir.kt
Vendored
-6
View File
@@ -1,6 +0,0 @@
sealed enum class SealedEnum {
FIRST,
SECOND;
class Derived: SealedEnum()
}

Some files were not shown because too many files have changed in this diff Show More