diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.kt index 995b779c47d..62e27409e88 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.kt @@ -7,7 +7,7 @@ interface FirFunctionCall : FirBase fun foo(statements: List, arguments: List, explicitReceiver: FirBase): List { val firstCalls = with(statements.last() as FirFunctionCall) setCall@{ - buildList { + buildList { add(this@setCall) with(arguments.last() as FirFunctionCall) plusCall@{ add(this@plusCall) diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInference.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInference.kt index 37b81062121..c9da07e28f1 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInference.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInference.kt @@ -1,4 +1,4 @@ -fun foo(@BuilderInference block: MutableList.() -> Unit): T = null!! +fun foo(@BuilderInference block: MutableList.() -> Unit): T = null!! fun takeString(s: String) {} diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceAndCoercionToUnit.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceAndCoercionToUnit.kt index a5cc7aa9a9b..8e42372635c 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceAndCoercionToUnit.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceAndCoercionToUnit.kt @@ -2,7 +2,7 @@ class DropDownComponent(val initialValues: List) fun test(strings: List) { val dropDown = DropDownComponent( - initialValues = buildList { + initialValues = buildList { addAll(strings) } ) diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceFromStdlib.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceFromStdlib.kt index 98426bfb87c..8f52040311f 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceFromStdlib.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceFromStdlib.kt @@ -1,5 +1,5 @@ fun test_1() { - val list = buildList { + val list = buildList { add("") } takeList(list) @@ -12,7 +12,7 @@ fun test_2() { takeList(list) } -fun myBuildList(@BuilderInference builderAction: MutableList.() -> Unit): List { +fun myBuildList(@BuilderInference builderAction: MutableList.() -> Unit): List { return ArrayList().apply(builderAction) } diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KtFirCompositeScope.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KtFirCompositeScope.kt index 12548ab432f..fcde33b65d6 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KtFirCompositeScope.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KtFirCompositeScope.kt @@ -2,7 +2,7 @@ interface KtScope { fun getAllNames(): Set } -inline fun buildSet(@BuilderInference builderAction: MutableSet.() -> Unit): Set { +inline fun buildSet(@BuilderInference builderAction: MutableSet.() -> Unit): Set { return null!! } diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 91aeac0076e..08275745996 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -34863,6 +34863,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt"); } + @Test + @TestMetadata("experimentalSetter.kt") + public void testExperimentalSetter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt"); + } + @Test @TestMetadata("fullFqNameUsage.kt") public void testFullFqNameUsage() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java index 08899a2c828..65ba8a502c1 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java @@ -34863,6 +34863,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt"); } + @Test + @TestMetadata("experimentalSetter.kt") + public void testExperimentalSetter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt"); + } + @Test @TestMetadata("fullFqNameUsage.kt") public void testFullFqNameUsage() throws Exception { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt index a0f666bc91d..828ba156851 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt @@ -23,6 +23,11 @@ object CommonExpressionCheckers : ExpressionCheckers() { FirDeprecationChecker, ) + override val qualifiedAccessCheckers: Set + get() = setOf( + FirOptInUsageAccessChecker, + ) + override val qualifiedAccessExpressionCheckers: Set get() = setOf( FirCallableReferenceChecker, @@ -115,6 +120,7 @@ object CommonExpressionCheckers : ExpressionCheckers() { override val resolvedQualifierCheckers: Set get() = setOf( FirStandaloneQualifierChecker, + FirOptInUsageQualifierChecker, ) override val equalityOperatorCallCheckers: Set diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonTypeCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonTypeCheckers.kt index 03ed2ce5619..f80c9f491ae 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonTypeCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonTypeCheckers.kt @@ -12,5 +12,6 @@ object CommonTypeCheckers : TypeCheckers() { FirTypeAnnotationChecker, FirSuspendModifierChecker, FirDeprecatedTypeChecker, + FirOptInUsageTypeRefChecker, ) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt index c69ab7884c5..b6ee82689ae 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt @@ -32,7 +32,7 @@ object FirClassLiteralChecker : FirGetClassCallChecker() { val argument = expression.argument if (argument is FirResolvedQualifier) { val fqName = argument.classId?.asSingleFqName() - if (fqName in OptInNames.EXPERIMENTAL_FQ_NAMES || fqName in OptInNames.USE_EXPERIMENTAL_FQ_NAMES) { + if (fqName == OptInNames.REQUIRES_OPT_IN_FQ_NAME || fqName == OptInNames.OPT_IN_FQ_NAME) { reporter.reportOn(argument.source, FirErrors.EXPERIMENTAL_CAN_ONLY_BE_USED_AS_ANNOTATION, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt new file mode 100644 index 00000000000..f71dc426cfd --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt @@ -0,0 +1,43 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.analysis.checkers.expression + +import org.jetbrains.kotlin.fir.FirFakeSourceElementKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess +import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment +import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved + +object FirOptInUsageAccessChecker : FirQualifiedAccessChecker() { + @OptIn(SymbolInternals::class) + override fun check(expression: FirQualifiedAccess, context: CheckerContext, reporter: DiagnosticReporter) { + val sourceKind = expression.source?.kind + if (sourceKind is FirFakeSourceElementKind.DataClassGeneratedMembers || + sourceKind is FirFakeSourceElementKind.PropertyFromParameter + ) return + val reference = expression.calleeReference as? FirResolvedNamedReference ?: return + val resolvedSymbol = reference.resolvedSymbol + resolvedSymbol.ensureResolved(FirResolvePhase.STATUS) + val fir = resolvedSymbol.fir as? FirAnnotatedDeclaration ?: return + with(FirOptInUsageBaseChecker) { + if (expression is FirVariableAssignment && fir is FirProperty) { + val experimentalities = fir.loadExperimentalities(context, fromSetter = true) + + loadExperimentalitiesFromTypeArguments(context, expression.typeArguments) + reportNotAcceptedExperimentalities(experimentalities, expression.lValue, context, reporter) + return + } + val experimentalities = fir.loadExperimentalities(context, fromSetter = false) + + loadExperimentalitiesFromTypeArguments(context, expression.typeArguments) + reportNotAcceptedExperimentalities(experimentalities, expression, context, reporter) + } + } +} \ No newline at end of file diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt index cd3a52e5085..81580dee8bc 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt @@ -5,6 +5,16 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression +import org.jetbrains.kotlin.config.AnalysisFlags +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.analysis.checkers.* +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.isLocal import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.findArgumentByName import org.jetbrains.kotlin.fir.declarations.getAnnotationByFqName @@ -12,12 +22,22 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.resolve.fullyExpandedType +import org.jetbrains.kotlin.fir.resolve.toFirRegularClass +import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.scopes.ProcessorAction +import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenFunctions +import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenProperties +import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.checkers.Experimentality import org.jetbrains.kotlin.resolve.checkers.OptInNames +import org.jetbrains.kotlin.utils.SmartSet +import org.jetbrains.kotlin.utils.addIfNotNull internal object FirOptInUsageBaseChecker { fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(): Experimentality? { @@ -26,8 +46,140 @@ internal object FirOptInUsageBaseChecker { return fir.loadExperimentalityForMarkerAnnotation() } + fun loadExperimentalitiesFromTypeArguments( + context: CheckerContext, + typeArguments: List + ): Set { + if (typeArguments.isEmpty()) return emptySet() + return loadExperimentalitiesFromConeArguments(context, typeArguments.map { it.toConeTypeProjection() }) + } + + fun loadExperimentalitiesFromConeArguments( + context: CheckerContext, + typeArguments: List + ): Set { + if (typeArguments.isEmpty()) return emptySet() + val result = SmartSet.create() + typeArguments.forEach { + if (!it.isStarProjection) it.type?.addExperimentalities(context, result) + } + return result + } + + fun FirAnnotatedDeclaration.loadExperimentalities( + context: CheckerContext, fromSetter: Boolean + ): Set = loadExperimentalities( + context, knownExperimentalities = null, visited = mutableSetOf(), fromSetter + ) + + @OptIn(SymbolInternals::class) + private fun FirAnnotatedDeclaration.loadExperimentalities( + context: CheckerContext, + knownExperimentalities: SmartSet?, + visited: MutableSet, + fromSetter: Boolean, + ): Set { + if (!visited.add(this)) return emptySet() + val result = knownExperimentalities ?: SmartSet.create() + val session = context.session + if (this is FirCallableDeclaration) { + val parentClass = containingClass()?.toFirRegularClass(session) + if (this.isSubstitutionOrIntersectionOverride) { + val parentClassScope = parentClass?.unsubstitutedScope(context) + if (this is FirSimpleFunction) { + parentClassScope?.processDirectlyOverriddenFunctions(symbol) { + it.fir.loadExperimentalities(context, result, visited, fromSetter = false) + ProcessorAction.NEXT + } + } else if (this is FirProperty) { + parentClassScope?.processDirectlyOverriddenProperties(symbol) { + it.fir.loadExperimentalities(context, result, visited, fromSetter) + ProcessorAction.NEXT + } + } + } + if (this !is FirConstructor) { + // Note: coneType here crashes on overridden members + returnTypeRef.coneTypeSafe().addExperimentalities(context, result, visited) + receiverTypeRef?.coneTypeSafe().addExperimentalities(context, result, visited) + if (this is FirSimpleFunction) { + valueParameters.forEach { + it.returnTypeRef.coneTypeSafe().addExperimentalities(context, result, visited) + } + } + } + parentClass?.loadExperimentalities(context, result, visited, fromSetter = false) + if (fromSetter && this is FirProperty) { + setter?.loadExperimentalities(context, result, visited, fromSetter = false) + } + } else if (this is FirRegularClass && !this.isLocal) { + val parentClassSymbol = symbol.outerClassSymbol(context) + parentClassSymbol?.fir?.loadExperimentalities(context, result, visited, fromSetter = false) + } + + for (annotation in annotations) { + val annotationType = annotation.annotationTypeRef.coneTypeSafe() + if (annotation.useSiteTarget != AnnotationUseSiteTarget.PROPERTY_SETTER || fromSetter) { + result.addIfNotNull( + annotationType?.lookupTag?.toFirRegularClass( + session + )?.loadExperimentalityForMarkerAnnotation() + ) + } + } + + if (this is FirTypeAlias) { + expandedTypeRef.coneType.addExperimentalities(context, result, visited) + } + + if (getAnnotationByFqName(OptInNames.WAS_EXPERIMENTAL_FQ_NAME) != null) { + val accessibility = checkSinceKotlinVersionAccessibility(context) + if (accessibility is FirSinceKotlinAccessibility.NotAccessibleButWasExperimental) { + accessibility.markerClasses.forEach { + it.ensureResolved(FirResolvePhase.STATUS) + result.addIfNotNull(it.fir.loadExperimentalityForMarkerAnnotation()) + } + } + } + + // TODO: getAnnotationsOnContainingModule + return result + } + + @OptIn(SymbolInternals::class) + private fun ConeKotlinType?.addExperimentalities( + context: CheckerContext, + result: SmartSet, + visited: MutableSet = mutableSetOf() + ) { + when (this) { + !is ConeClassLikeType -> return + else -> { + val expandedType = fullyExpandedType(context.session) + if (this === expandedType) { + expandedType.lookupTag.toFirRegularClass(context.session)?.loadExperimentalities( + context, result, visited, fromSetter = false + ) + typeArguments.forEach { + if (!it.isStarProjection) it.type?.addExperimentalities(context, result, visited) + } + } else { + val symbol = lookupTag.toSymbol(context.session) + if (symbol != null) { + symbol.ensureResolved(FirResolvePhase.STATUS) + symbol.fir.loadExperimentalities(context, result, visited, fromSetter = false) + } + expandedType.typeArguments.forEach { + if (!it.isStarProjection) it.type?.addExperimentalities(context, result, visited) + } + } + } + } + } + private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(): Experimentality? { - val experimental = getAnnotationByFqName(OptInNames.REQUIRES_OPT_IN_FQ_NAME) ?: return null + val experimental = getAnnotationByFqName(OptInNames.REQUIRES_OPT_IN_FQ_NAME) + ?: return null val levelArgument = experimental.findArgumentByName(LEVEL) as? FirQualifiedAccessExpression val levelName = (levelArgument?.calleeReference as? FirResolvedNamedReference)?.name?.asString() @@ -36,6 +188,73 @@ internal object FirOptInUsageBaseChecker { return Experimentality(symbol.classId.asSingleFqName(), level.severity, message) } + fun reportNotAcceptedExperimentalities( + experimentalities: Collection, + element: FirElement, + context: CheckerContext, + reporter: DiagnosticReporter + ) { + for ((annotationFqName, severity, message) in experimentalities) { + if (!isExperimentalityAcceptableInContext(annotationFqName, element, context)) { + val diagnostic = when (severity) { + Experimentality.Severity.WARNING -> FirErrors.EXPERIMENTAL_API_USAGE + Experimentality.Severity.ERROR -> FirErrors.EXPERIMENTAL_API_USAGE_ERROR + } + val reportedMessage = message ?: when (severity) { + Experimentality.Severity.WARNING -> "This declaration is experimental and its usage should be marked" + Experimentality.Severity.ERROR -> "This declaration is experimental and its usage must be marked" + } + reporter.reportOn(element.source, diagnostic, annotationFqName, reportedMessage, context) + } + } + } + + private fun isExperimentalityAcceptableInContext( + annotationFqName: FqName, + element: FirElement, + context: CheckerContext + ): Boolean { + val languageVersionSettings = context.session.languageVersionSettings + val fqNameAsString = annotationFqName.asString() + if (fqNameAsString in languageVersionSettings.getFlag(AnalysisFlags.useExperimental)) { + return true + } + for (declaration in context.containingDeclarations) { + if (declaration !is FirAnnotatedDeclaration) continue + if (declaration.isExperimentalityAcceptable(annotationFqName)) { + return true + } + } + for (accessOrAnnotation in context.qualifiedAccessOrAnnotationCalls) { + if (accessOrAnnotation.isExperimentalityAcceptable(annotationFqName)) { + return true + } + } + if (element !is FirAnnotationContainer) return false + return element.isExperimentalityAcceptable(annotationFqName) + } + + private fun FirAnnotationContainer.isExperimentalityAcceptable(annotationFqName: FqName): Boolean { + return getAnnotationByFqName(annotationFqName) != null || isAnnotatedWithUseExperimentalOf(annotationFqName) + } + + private fun FirAnnotationContainer.isAnnotatedWithUseExperimentalOf(annotationFqName: FqName): Boolean { + for (annotation in annotations) { + val coneType = annotation.annotationTypeRef.coneType as? ConeClassLikeType + if (coneType?.lookupTag?.classId?.asSingleFqName() != OptInNames.OPT_IN_FQ_NAME) { + continue + } + val annotationClasses = annotation.findArgumentByName(OptInNames.USE_EXPERIMENTAL_ANNOTATION_CLASS) ?: continue + if (annotationClasses.extractClassesFromArgument().any { + it.classId.asSingleFqName() == annotationFqName + } + ) { + return true + } + } + return false + } + private val LEVEL = Name.identifier("level") private val MESSAGE = Name.identifier("message") diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageQualifierChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageQualifierChecker.kt new file mode 100644 index 00000000000..2d363854a75 --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageQualifierChecker.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.analysis.checkers.expression + +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved + +object FirOptInUsageQualifierChecker : FirResolvedQualifierChecker() { + @OptIn(SymbolInternals::class) + override fun check(expression: FirResolvedQualifier, context: CheckerContext, reporter: DiagnosticReporter) { + val symbol = expression.symbol ?: return + symbol.ensureResolved(FirResolvePhase.STATUS) + val fir = symbol.fir + with(FirOptInUsageBaseChecker) { + val experimentalities = fir.loadExperimentalities(context, fromSetter = false) + reportNotAcceptedExperimentalities(experimentalities, expression, context, reporter) + } + } +} \ No newline at end of file diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt new file mode 100644 index 00000000000..72e4175a087 --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.analysis.checkers.type + +import org.jetbrains.kotlin.fir.FirRealSourceElementKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirOptInUsageBaseChecker +import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.ensureResolved +import org.jetbrains.kotlin.fir.types.ConeClassLikeType +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.coneTypeSafe +import org.jetbrains.kotlin.resolve.checkers.OptInNames + +object FirOptInUsageTypeRefChecker : FirTypeRefChecker() { + @OptIn(SymbolInternals::class) + override fun check(typeRef: FirTypeRef, context: CheckerContext, reporter: DiagnosticReporter) { + if (typeRef.source?.kind !is FirRealSourceElementKind) return + val coneType = typeRef.coneTypeSafe() ?: return + val symbol = coneType.lookupTag.toSymbol(context.session) ?: return + symbol.ensureResolved(FirResolvePhase.STATUS) + val fqName = symbol.classId.asSingleFqName() + val lastAnnotationCall = context.qualifiedAccessOrAnnotationCalls.lastOrNull() as? FirAnnotationCall + if ((lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) && + (fqName == OptInNames.REQUIRES_OPT_IN_FQ_NAME || fqName == OptInNames.OPT_IN_FQ_NAME) + ) { + reporter.reportOn(typeRef.source, FirErrors.EXPERIMENTAL_CAN_ONLY_BE_USED_AS_ANNOTATION, context) + } + + with(FirOptInUsageBaseChecker) { + val experimentalities = symbol.fir.loadExperimentalities(context, fromSetter = false) + + loadExperimentalitiesFromConeArguments(context, coneType.typeArguments.toList()) + reportNotAcceptedExperimentalities(experimentalities, typeRef, context, reporter) + } + } +} \ No newline at end of file diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt index 32958ad11aa..3c852020e00 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt @@ -57,6 +57,7 @@ class ValueParameter( initializer = buildQualifiedAccessExpression { source = propertySource calleeReference = buildPropertyFromParameterResolvedNamedReference { + source = propertySource this.name = name resolvedSymbol = this@ValueParameter.firValueParameter.symbol source = propertySource diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.kt b/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.kt index b4f6c80e94a..11d9180875a 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.kt @@ -5,7 +5,7 @@ // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R = TODO() interface TestInterface { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.txt b/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.txt index 3bd18b8f535..39ea44b5681 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.txt @@ -1,6 +1,6 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R public fun main(): kotlin.Unit public interface TestInterface { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt index f1298dc4444..85598b69b00 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt @@ -3,7 +3,7 @@ import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun combined( check: () -> Unit, @BuilderInference block: TestInterface.() -> Unit diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt b/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt index 72bcb817bda..ed8ace04823 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt @@ -3,7 +3,7 @@ import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun combined( check: () -> Unit, @BuilderInference block: TestInterface.() -> Unit diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.txt b/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.txt index c8f53812378..ec07844fd2f 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.txt @@ -1,6 +1,6 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun combined(/*0*/ check: () -> kotlin.Unit, /*1*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun combined(/*0*/ check: () -> kotlin.Unit, /*1*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R public fun test(): kotlin.Unit public interface TestInterface { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.fir.kt index 059332a5984..f1a5d7808b4 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.fir.kt @@ -5,10 +5,10 @@ // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R = TODO() interface TestInterface { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt index 209a231fe35..26a78a97b8e 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt @@ -5,10 +5,10 @@ // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R = TODO() interface TestInterface { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.txt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.txt index 84f85769a70..2ce5ffa5eb6 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.txt @@ -1,7 +1,7 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R public fun capture(/*0*/ x: Inv): K public fun captureIn(/*0*/ x: Inv): K public fun captureOut(/*0*/ x: Inv): K diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.fir.kt index 1495c56ef5c..429f713eb24 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.fir.kt @@ -11,10 +11,10 @@ class Test { // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R2 = TODO() class In diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.kt index bb99cea4a01..e2a81e295f3 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.kt @@ -11,10 +11,10 @@ class Test { // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R2 = TODO() class In diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.txt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.txt index 6270a2eec95..53b0f3a07b9 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.txt @@ -1,7 +1,7 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R2 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R2 public fun id(/*0*/ x: U): U? public fun select1(/*0*/ x: E, /*1*/ y: In): E? public fun select2(/*0*/ x: E, /*1*/ y: In): E diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt index 82aa4230b4b..f3d89d25b55 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt @@ -11,10 +11,10 @@ class Test { // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R2 = TODO() class Inv diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt index 07d2980d68d..d34b768f0e8 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt @@ -11,10 +11,10 @@ class Test { // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R2 = TODO() class Inv diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.txt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.txt index 56dacc97171..b602a7a791c 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.txt @@ -1,7 +1,7 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R2 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R2 public fun id(/*0*/ x: U): U? public fun select1(/*0*/ x: E, /*1*/ y: Inv): E? public fun select2(/*0*/ x: E, /*1*/ y: Inv): E diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.fir.kt index e6caa8beb7d..23b5046043e 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.fir.kt @@ -11,10 +11,10 @@ class Test { // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R2 = TODO() class In diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt index ef58760e653..d1e3bda3050 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt @@ -11,10 +11,10 @@ class Test { // FILE: main.kt import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R2 = TODO() class In diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.txt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.txt index 947652f01d6..c56982c82ac 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.txt @@ -1,7 +1,7 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R2 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R2 public fun id(/*0*/ x: U): U public fun intersect(/*0*/ vararg x: In /*kotlin.Array>*/): E public fun test(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt index 071bbae9202..675106f6275 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt @@ -10,7 +10,7 @@ interface TestInterface { fun get(): R } -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() fun Any.test() {} diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt index c938e6cacee..ff634fe9ec0 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt @@ -10,7 +10,7 @@ interface TestInterface { fun get(): R } -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() fun Any.test() {} diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.txt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.txt index 919b61fb191..74757fd1d8c 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.txt @@ -1,6 +1,6 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 public fun test(): kotlin.Unit public fun kotlin.Any.test(): kotlin.Unit public fun kotlin.Any?.test2(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.fir.kt index 9df0149a11d..c442d2a3084 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.fir.kt @@ -10,16 +10,16 @@ interface TestInterface { fun get(): R } -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build3(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build4(x: R2, @BuilderInference block: TestInterface.() -> Unit): R1 = TODO() fun test(a: String?) { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.kt index 86dd1a6f2b6..9b41d17072a 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.kt @@ -10,16 +10,16 @@ interface TestInterface { fun get(): R } -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build2(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build3(@BuilderInference block: TestInterface.() -> Unit): R1 = TODO() -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build4(x: R2, @BuilderInference block: TestInterface.() -> Unit): R1 = TODO() fun test(a: String?) { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.txt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.txt index 968e28c5210..b6666359039 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.txt @@ -1,9 +1,9 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build3(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build4(/*0*/ x: R2, /*1*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build2(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build3(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build4(/*0*/ x: R2, /*1*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R1 public fun test(/*0*/ a: kotlin.String?): kotlin.Unit public interface TestInterface { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.fir.kt index 5e9e16562c2..96a2acbb4ba 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.fir.kt @@ -4,7 +4,7 @@ import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build( @BuilderInference block: TestInterface.() -> Unit ): R = TODO() diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt index 65d431e1e04..01d55942b6d 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt @@ -4,7 +4,7 @@ import kotlin.experimental.ExperimentalTypeInference -@UseExperimental(ExperimentalTypeInference::class) +@OptIn(ExperimentalTypeInference::class) fun build( @BuilderInference block: TestInterface.() -> Unit ): R = TODO() diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.txt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.txt index 48e00535041..1a34195dc98 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.txt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.txt @@ -1,6 +1,6 @@ package -@kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R +@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun build(/*0*/ @kotlin.BuilderInference block: TestInterface.() -> kotlin.Unit): R public fun id(/*0*/ x: U): U public fun test(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt new file mode 100644 index 00000000000..364bff0aaa1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt @@ -0,0 +1,12 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +fun ubyte(vararg a: UByte) {} +fun ushort(vararg a: UShort) {} +fun uint(vararg a: UInt) {} +fun ulong(vararg a: ULong) {} + +class ValueParam(vararg val a: ULong) + +annotation class Ann(vararg val a: UInt) + +fun array(vararg a: UIntArray) {} diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt index fbf95cf3401..bd99c3ecfec 100644 --- a/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER fun ubyte(vararg a: UByte) {} diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt index 3634de0816a..ecff0059c92 100644 --- a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt @@ -33,7 +33,7 @@ fun takeUShort(@ImplicitIntegerCoercion u: UShort) {} fun takeUInt(@ImplicitIntegerCoercion u: UInt) {} fun takeULong(@ImplicitIntegerCoercion u: ULong) {} -fun takeUBytes(@ImplicitIntegerCoercion vararg u: UByte) {} +fun takeUBytes(@ImplicitIntegerCoercion vararg u: UByte) {} fun takeLong(@ImplicitIntegerCoercion l: Long) {} diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt index fd93faf34f0..506abee719f 100644 --- a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt @@ -5,7 +5,7 @@ fun takeUShort(u: UShort) {} fun takeUInt(u: UInt) {} fun takeULong(u: ULong) {} -fun takeUBytes(vararg u: UByte) {} +fun takeUBytes(vararg u: UByte) {} fun takeNullableUInt(u: UInt?) {} diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt index ece5be15fb7..bd2717bb88d 100644 --- a/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt @@ -1,7 +1,7 @@ -fun ubyte(vararg a: UByte): UByteArray = a -fun ushort(vararg a: UShort): UShortArray = a -fun uint(vararg a: UInt): UIntArray = a -fun ulong(vararg a: ULong): ULongArray = a +fun ubyte(vararg a: UByte): UByteArray = a +fun ushort(vararg a: UShort): UShortArray = a +fun uint(vararg a: UInt): UIntArray = a +fun ulong(vararg a: ULong): ULongArray = a -fun rawUInt(vararg a: UInt): IntArray = a +fun rawUInt(vararg a: UInt): IntArray = a diff --git a/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt b/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt index a2f0adc0504..ca076f9bb1f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt @@ -1,4 +1,5 @@ // FIR_IDENTICAL +// ALLOW_KOTLIN_PACKAGE // !LANGUAGE: +UnrestrictedBuilderInference // !DIAGNOSTICS: -UNUSED_PARAMETER // FILE: annotation.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.fir.kt index bf6be779791..f56fe7ef2d5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.fir.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER +// ALLOW_KOTLIN_PACKAGE // !WITH_NEW_INFERENCE // FILE: annotation.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.kt b/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.kt index a193991da3a..08c3e7e8456 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER +// ALLOW_KOTLIN_PACKAGE // !WITH_NEW_INFERENCE // FILE: annotation.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt b/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt index 810fe20c229..a6588a43bc9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt @@ -1,4 +1,5 @@ // FIR_IDENTICAL +// ALLOW_KOTLIN_PACKAGE // !LANGUAGE: +UnrestrictedBuilderInference // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.fir.kt index 7d3b5587ce2..38b3a1c3982 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.fir.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER +// ALLOW_KOTLIN_PACKAGE // FILE: annotation.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt b/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt index e0eb81b8a56..fa807333c5e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER +// ALLOW_KOTLIN_PACKAGE // FILE: annotation.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.fir.kt deleted file mode 100644 index 6c75d289c70..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.fir.kt +++ /dev/null @@ -1,138 +0,0 @@ -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// !DIAGNOSTICS: -UNUSED_PARAMETER -// FILE: api.kt - -package api - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS, - AnnotationTarget.VALUE_PARAMETER) -@Retention(AnnotationRetention.BINARY) -annotation class ExperimentalAPI - -@ExperimentalAPI -@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS, - AnnotationTarget.VALUE_PARAMETER) -@Retention(AnnotationRetention.BINARY) -annotation class EAnno - -// FILE: usage-propagate.kt - -package usage1 - -import api.* - -@ExperimentalAPI -@EAnno fun function() {} - -@ExperimentalAPI -fun parameter(@EAnno p: String) {} - -@ExperimentalAPI -fun parameterType(p: @EAnno String) {} - -@ExperimentalAPI -fun returnType(): @EAnno Unit {} - -@ExperimentalAPI -@EAnno val property = "" - -@ExperimentalAPI -@EAnno typealias Typealias = Unit - -@ExperimentalAPI -@EAnno class Klass - -@ExperimentalAPI -annotation class AnnotationArgument(val p: EAnno) - -@ExperimentalAPI -fun insideBody() { - @EAnno fun local() {} -} - -@ExperimentalAPI -fun inDefaultArgument(f: () -> Unit = @EAnno fun() {}) {} - -@ExperimentalAPI -val inProperty = @EAnno fun() {} - -@ExperimentalAPI -val inPropertyAccessor: () -> Unit - get() = @EAnno fun() {} - -// FILE: usage-use.kt - -package usage2 - -import api.* - -@OptIn(ExperimentalAPI::class) -@EAnno fun function() {} - -@OptIn(ExperimentalAPI::class) -fun parameter(@EAnno p: String) {} - -@OptIn(ExperimentalAPI::class) -fun parameterType(p: @EAnno String) {} - -@OptIn(ExperimentalAPI::class) -fun returnType(): @EAnno Unit {} - -@OptIn(ExperimentalAPI::class) -@EAnno val property = "" - -@OptIn(ExperimentalAPI::class) -@EAnno typealias Typealias = Unit - -@OptIn(ExperimentalAPI::class) -@EAnno class Klass - -@OptIn(ExperimentalAPI::class) -annotation class AnnotationArgument(val p: EAnno) - -fun insideBody() { - @OptIn(ExperimentalAPI::class) @EAnno fun local() {} -} - -fun inDefaultArgument(@OptIn(ExperimentalAPI::class) f: () -> Unit = @EAnno fun() {}) {} - -@OptIn(ExperimentalAPI::class) -val inProperty = @EAnno fun() {} - -val inPropertyAccessor: () -> Unit - @OptIn(ExperimentalAPI::class) - get() = @EAnno fun() {} - -// FILE: usage-none.kt - -package usage3 - -import api.* - -@EAnno fun function() {} - -fun parameter(@EAnno p: String) {} - -fun parameterType(p: @EAnno String) {} - -fun returnType(): @EAnno Unit {} - -@EAnno val property = "" - -@EAnno typealias Typealias = Unit - -@EAnno class Klass - -annotation class AnnotationArgument(val p: EAnno) - -fun insideBody() { - @EAnno fun local() {} -} - -fun inDefaultArgument(f: () -> Unit = @EAnno fun() {}) {} - -val inProperty = @EAnno fun() {} - -val inPropertyAccessor: () -> Unit - get() = @EAnno fun() {} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.kt index 3ad625d713e..8aa1ca97c14 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // !DIAGNOSTICS: -UNUSED_PARAMETER // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.fir.kt deleted file mode 100644 index 7a259fd1178..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.fir.kt +++ /dev/null @@ -1,84 +0,0 @@ -// !DIAGNOSTICS: -NOTHING_TO_INLINE -UNUSED_PARAMETER -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// FILE: api.kt - -package api - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Retention(AnnotationRetention.BINARY) -annotation class API - -@API -fun f() {} - -// FILE: usage.kt - -package usage - -import api.* - -fun use1() { - f() -} - -val use2 = f() - -// FILE: inline-usage.kt - -package usage - -import api.* - -inline fun inlineUse1() { - f() -} - -inline var inlineUse2: Unit - get() { - f() - } - set(value) { - f() - } - -var inlineUse3: Unit - inline get() { - f() - } - @API - inline set(value) { - f() - } - -@API -inline fun inlineUse4() { - f() -} - -// FILE: private-inline-usage.kt - -package usage - -import api.* - -private inline fun privateInline1() { - f() -} - -internal inline fun privateInline2() { - f() -} - -private inline var privateInline3: Unit - get() { - f() - } - set(value) { - f() - } - -internal class InternalClass { - inline fun privateInline4() { - f() - } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.kt index 19c2a5546df..a1e0c9d0e1e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -NOTHING_TO_INLINE -UNUSED_PARAMETER // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.fir.kt deleted file mode 100644 index 9840eb4985a..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.fir.kt +++ /dev/null @@ -1,89 +0,0 @@ -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// FILE: api.kt - -package api - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION) -@Retention(AnnotationRetention.BINARY) -annotation class ExperimentalAPI - -@ExperimentalAPI -class C { - fun function(): String = "" - val property: String = "" - class Nested - inner class Inner -} - -@ExperimentalAPI -fun C.extension() {} - -// FILE: usage-propagate.kt - -package usage1 - -import api.* - -@ExperimentalAPI -fun useAll() { - val c: C = C() - c.function() - c.property - C.Nested() - c.Inner() - c.extension() -} - -@ExperimentalAPI -class Use { - fun useAll(c: C) { - c.function() - c.property - C.Nested() - c.Inner() - c.extension() - } -} - -// FILE: usage-use.kt - -package usage2 - -import api.* - -@OptIn(ExperimentalAPI::class) -fun useAll() { - val c: C = C() - c.function() - c.property - C.Nested() - c.Inner() - c.extension() -} - -@OptIn(ExperimentalAPI::class) -class Use { - fun useAll(c: C) { - c.function() - c.property - C.Nested() - c.Inner() - c.extension() - } -} - -// FILE: usage-none.kt - -package usage3 - -import api.* - -fun use() { - val c: C = C() - c.function() - c.property - C.Nested() - c.Inner() - c.extension() -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.kt index b0b6b1e44d8..d390e4a5e02 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.fir.kt deleted file mode 100644 index 2839cc25257..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.fir.kt +++ /dev/null @@ -1,37 +0,0 @@ -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// FILE: api.kt - -package api - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY) -@Retention(AnnotationRetention.BINARY) -annotation class ExperimentalAPI - -@ExperimentalAPI -class C { - @ExperimentalAPI - fun function() {} - - @ExperimentalAPI - val property: String = "" - - @ExperimentalAPI - class Nested { - @ExperimentalAPI - fun nestedFunction() {} - } -} - -// FILE: usage.kt - -package usage - -import api.* - -fun use() { - val c: C = C() - c.function() - c.property - C.Nested().nestedFunction() -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.kt index 91c7e04a3d9..ec8df0f964d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/constVal.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/constVal.fir.kt index 51a76bb11ed..d13a4c29aa4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/constVal.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/constVal.fir.kt @@ -40,5 +40,5 @@ package usage3 import api.* -@Anno(MEANING) +@Anno(MEANING) fun usage() {} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/deeplyNestedClass.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/deeplyNestedClass.fir.kt index 51f61ffd04d..635810cb678 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/deeplyNestedClass.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/deeplyNestedClass.fir.kt @@ -52,7 +52,7 @@ package usage3 import api.* fun use1() { - C.D.E.F() + C.D.E.F() } -fun use2(f: C.D.E.F) = f.hashCode() +fun use2(f: C.D.E.F) = f.hashCode() diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/errors.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/errors.fir.kt index abec45129a1..68fa30bf603 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/errors.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/errors.fir.kt @@ -23,5 +23,5 @@ class Derived : Base() { } fun test(b: Base) { - b.foo() + b.foo() } diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.fir.kt deleted file mode 100644 index cd63d0e74f1..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.fir.kt +++ /dev/null @@ -1,24 +0,0 @@ -// FILE: api.kt - -@RequiresOptIn -@Retention(AnnotationRetention.BINARY) -annotation class Marker - -@Marker -fun f() {} - -// FILE: usage.kt - -fun use1() { - f() -} - -@Marker -fun use2() { - f() -} - -@OptIn(Marker::class) -fun use3() { - f() -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt index 62eb555f97b..44c8bd04680 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: api.kt @RequiresOptIn diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt new file mode 100644 index 00000000000..b8b2390f2ad --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt @@ -0,0 +1,24 @@ +// FIR_IDENTICAL +// !USE_EXPERIMENTAL: kotlin.RequiresOptIn + +@RequiresOptIn +@Retention(AnnotationRetention.BINARY) +annotation class E + +@set:E +var x: Int = 42 + +@E +var y: Int = 24 + +var z: Int = 44 + @E set(arg) { + field = arg + } + +fun user(): Int { + x = 10 + y = 5 + x = 15 + return x + y + z +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.txt b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.txt new file mode 100644 index 00000000000..68c98781c07 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.txt @@ -0,0 +1,13 @@ +package + +@set:E public var x: kotlin.Int +@E public var y: kotlin.Int +@set:E public var z: kotlin.Int +public fun user(): kotlin.Int + +@kotlin.RequiresOptIn @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class E : kotlin.Annotation { + public constructor E() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/implicitUsages.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/implicitUsages.fir.kt index 472f2a470d1..158810509e3 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/implicitUsages.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/implicitUsages.fir.kt @@ -9,15 +9,15 @@ annotation class Marker interface Some abstract class User { - abstract fun createSome(): Some - fun Some?.onSome() {} - fun withSome(some: Some? = null) {} + abstract fun createSome(): Some + fun Some?.onSome() {} + fun withSome(some: Some? = null) {} fun use() { - val something = createSome() - val somethingOther: Some = createSome() - null.onSome() - withSome() + val something = createSome() + val somethingOther: Some = createSome() + null.onSome() + withSome() } } @@ -25,15 +25,15 @@ data class DataClass(@property:Marker val x: Int) fun useDataClass(d: DataClass) { // Should have error in both - d.x + d.x val (x) = d } -typealias My = Some +typealias My = Some -fun my(my: My) {} +fun my(my: My) {} -fun your(my: Some) {} +fun your(my: Some) {} @Marker interface ExperimentalType { @@ -48,7 +48,7 @@ interface NotExperimentalExtension : ExperimentalType { fun use(arg: NotExperimentalExtension) { arg.foo() - arg.bar() + arg.bar() } @Marker @@ -67,7 +67,7 @@ typealias MyList = ArrayList typealias YourList = ArrayList fun main() { - val x = listOf(A(), B()) + val x = listOf(A(), B()) val y = MyList() val z = YourList() YourList().add("") @@ -83,7 +83,7 @@ object O { operator fun provideDelegate(x: Any?, y: Any?): C = C() } -val x: String by O +val x: String by O @Marker class OperatorContainer : Comparable { @@ -116,8 +116,8 @@ operator fun String.minus(s: String) = OperatorContainer() operator fun String.invoke() = OperatorContainer() fun operatorContainerUsage(s: String, a: AnotherContainer) { - val res1 = s - s - val res2 = s() - val res3 = res1 > res2 - for (c in a) {} + val res1 = s - s + val res2 = s() + val res3 = res1 > res2 + for (c in a) {} } \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.fir.kt deleted file mode 100644 index 0a3fb3f5378..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.fir.kt +++ /dev/null @@ -1,79 +0,0 @@ -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// !DIAGNOSTICS: -UNUSED_VARIABLE -// FILE: api.kt - -package api - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS, - AnnotationTarget.VALUE_PARAMETER) -@Retention(AnnotationRetention.BINARY) -annotation class ExperimentalAPI - -@ExperimentalAPI -fun function(): String = "" - -@ExperimentalAPI -val property: String = "" - -@ExperimentalAPI -typealias Typealias = String - -// FILE: usage-propagate.kt - -package usage1 - -import api.* - -@ExperimentalAPI -fun useAll() { - function() - property - val s: Typealias = "" -} - -@ExperimentalAPI -class Use { - fun useAll() { - function() - property - val s: Typealias = "" - } -} - -// FILE: usage-use.kt - -package usage2 - -import api.* - -fun useAll() { - @OptIn(ExperimentalAPI::class) - { - function() - property - val s: Typealias = "" - }() -} - -@OptIn(ExperimentalAPI::class) -class Use { - fun useAll() { - function() - property - val s: Typealias = "" - } -} - -// FILE: usage-none.kt - -package usage3 - -import api.* - -fun use() { - function() - property - val s: Typealias = "" - s.hashCode() -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.kt index 895efd21684..20c4b19f417 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.fir.kt deleted file mode 100644 index 8dbc8b6eb7d..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.fir.kt +++ /dev/null @@ -1,14 +0,0 @@ -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// FILE: api.kt - -package api - -@RequiresOptIn -@Target(AnnotationTarget.CLASS) -@Retention(AnnotationRetention.BINARY) -annotation class ExperimentalAPI - -@ExperimentalAPI -class Foo - -typealias Bar = Foo diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.kt index 7971d0a5ebc..da925b7db54 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/usageNotAsAnnotation.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/usageNotAsAnnotation.fir.kt index 3736163f8d3..b02a73de3aa 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/usageNotAsAnnotation.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/usageNotAsAnnotation.fir.kt @@ -21,11 +21,11 @@ annotation class M // Usages as types should be errors -fun f1(e: RequiresOptIn) {} -fun f2(u: OptIn?) {} +fun f1(e: RequiresOptIn) {} +fun f2(u: OptIn?) {} -typealias Experimental0 = RequiresOptIn -typealias OptIn0 = OptIn +typealias Experimental0 = RequiresOptIn +typealias OptIn0 = OptIn fun f3(e: Experimental0 /* TODO */) {} fun f4(u: OptIn0 /* TODO */) {} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.fir.kt deleted file mode 100644 index cd69530b2bf..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.fir.kt +++ /dev/null @@ -1,39 +0,0 @@ -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// FILE: api.kt - -package api - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.FUNCTION) -@Retention(AnnotationRetention.BINARY) -annotation class ExperimentalAPI1 - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.FUNCTION) -@Retention(AnnotationRetention.BINARY) -annotation class ExperimentalAPI2 - -@ExperimentalAPI1 -fun compilation() {} - -@ExperimentalAPI2 -fun runtime() {} - -// FILE: usage.kt - -@file:OptIn(ExperimentalAPI1::class) -package usage - -import api.* - -fun use() { - compilation() - runtime() -} - -class Use { - fun use() { - compilation() - runtime() - } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.kt index a3ec21e0e38..9959d8bbbe4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.kt index 1048be83bcf..9f40589c284 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.kt @@ -1,4 +1,5 @@ // FIR_IDENTICAL +// FIR_IDE_IGNORE // !USE_EXPERIMENTAL: kotlin.RequiresOptIn api.ExperimentalAPI // MODULE: api // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.fir.kt deleted file mode 100644 index b0513efe4ba..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.fir.kt +++ /dev/null @@ -1,55 +0,0 @@ -// !USE_EXPERIMENTAL: kotlin.RequiresOptIn -// FILE: api.kt - -package api - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.FUNCTION) -@Retention(AnnotationRetention.BINARY) -annotation class E1 - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.FUNCTION) -@Retention(AnnotationRetention.BINARY) -annotation class E2 - -@RequiresOptIn(level = RequiresOptIn.Level.WARNING) -@Target(AnnotationTarget.FUNCTION) -@Retention(AnnotationRetention.BINARY) -annotation class E3 - -@E1 -fun e1() {} - -@E2 -fun e2() {} - -@E3 -fun e3() {} - -// FILE: usage.kt - -package usage - -import api.* - -@OptIn(E1::class, E2::class, E3::class) -fun use1() { - e1() - e2() - e3() -} - -@OptIn(E1::class, E3::class) -fun use2() { - e1() - @OptIn(E2::class) e2() - e3() -} - -@OptIn(E1::class, E2::class) -fun use3() { - e1() - e2() - e3() -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.kt index f68256bebaa..3b08b28827d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !USE_EXPERIMENTAL: kotlin.RequiresOptIn // FILE: api.kt diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/kt34391.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/regression/kt34391.fir.kt index 16e588632e9..93316445f67 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/regression/kt34391.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/regression/kt34391.fir.kt @@ -2,9 +2,9 @@ fun main() { val list = listOf(A()) - list.forEach(A::foo) + list.forEach(A::foo) list.forEach { - it.foo() + it.foo() } } diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 42545d7dc44..dfa417db31a 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -34959,6 +34959,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt"); } + @Test + @TestMetadata("experimentalSetter.kt") + public void testExperimentalSetter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt"); + } + @Test @TestMetadata("fullFqNameUsage.kt") public void testFullFqNameUsage() throws Exception { diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java index 22d4bd92d08..a8c2ae9998c 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java @@ -34863,6 +34863,12 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt"); } + @Test + @TestMetadata("experimentalSetter.kt") + public void testExperimentalSetter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt"); + } + @Test @TestMetadata("fullFqNameUsage.kt") public void testFullFqNameUsage() throws Exception {