From 1f0d56e15775e67808570f9127aed890b55ef6c9 Mon Sep 17 00:00:00 2001 From: Kirill Rakhman Date: Tue, 14 Mar 2023 17:20:35 +0100 Subject: [PATCH] [FIR] Make type parameters inaccessible for non-inner nested types #KT-57209 --- .../outerClassTypeParamsSubstitution.kt | 6 +- ...uterClassTypeParamsSubstitution.pretty.txt | 4 +- .../outerClassTypeParamsSubstitution.txt | 8 +- ...CompilerTestFE10TestdataTestGenerated.java | 6 + ...sticCompilerFE10TestDataTestGenerated.java | 6 + .../resolve/typeParameterVsNested.fir.txt | 2 +- ...eeOldFrontendDiagnosticsTestGenerated.java | 6 + ...siOldFrontendDiagnosticsTestGenerated.java | 6 + .../FirPropertyAccessorsTypesChecker.kt | 3 +- .../expression/FirWhenConditionChecker.kt | 8 +- .../kotlin/fir/types/ConeTypeUtils.kt | 5 + .../transformers/FirTypeResolveTransformer.kt | 101 +++++++++++------ .../transformers/ScopeClassDeclaration.kt | 2 +- .../funInterfaceDeclarationCheck.fir.kt | 104 ------------------ .../funInterfaceDeclarationCheck.kt | 1 + .../outerTypeParametersInNestedClasses.fir.kt | 39 +++++++ .../outerTypeParametersInNestedClasses.kt | 39 +++++++ .../tests/inner/outerGenericParam.fir.kt | 4 +- .../test/runners/DiagnosticTestGenerated.java | 6 + .../p-5/neg/1.1.fir.kt | 24 ++-- .../p-5/neg/1.2.fir.kt | 8 +- .../p-5/neg/2.1.fir.kt | 8 +- .../p-5/neg/3.1.fir.kt | 8 +- .../p-1/neg/2.1.fir.kt | 4 +- 24 files changed, 227 insertions(+), 181 deletions(-) delete mode 100644 compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.fir.kt create mode 100644 compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.fir.kt create mode 100644 compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt diff --git a/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.kt b/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.kt index b3c48d1b6ac..648872324fa 100644 --- a/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.kt +++ b/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.kt @@ -1,11 +1,11 @@ class Outer { - class A { + inner class A { fun foo(x: X, y: Y): Map> val map: Map } } -fun foo(a: Outer.A) { +fun foo(a: Outer.A) { println(a) -} \ No newline at end of file +} diff --git a/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.pretty.txt b/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.pretty.txt index 9dec9c0a010..2823c59576d 100644 --- a/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.pretty.txt +++ b/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.pretty.txt @@ -1,6 +1,6 @@ KtTypeScope: -fun foo(x: kotlin.Int, y: Y): kotlin.collections.Map> -val map: kotlin.collections.Map +fun foo(x: kotlin.Int, y: Y): kotlin.collections.Map> +val map: kotlin.collections.Map fun equals(other: kotlin.Any?): kotlin.Boolean fun hashCode(): kotlin.Int fun toString(): kotlin.String diff --git a/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.txt b/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.txt index bb4af955b03..75a82f276b1 100644 --- a/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.txt +++ b/analysis/analysis-api/testData/components/scopeProvider/typeScope/outerClassTypeParamsSubstitution.txt @@ -1,11 +1,11 @@ expression: a -KtType: Outer.A +KtType: Outer.A KtTypeScope: KtFunctionLikeSignature: receiverType = null - returnType = kotlin.collections.Map> - symbol = /Outer.A.foo(: Outer.A, x: X, y: Y): kotlin.collections.Map> + returnType = kotlin.collections.Map> + symbol = /Outer.A.foo(: Outer.A, x: X, y: Y): kotlin.collections.Map> valueParameters = [ KtVariableLikeSignature: name = x @@ -24,7 +24,7 @@ KtFunctionLikeSignature: KtVariableLikeSignature: name = map receiverType = null - returnType = kotlin.collections.Map + returnType = kotlin.collections.Map symbol = val map: kotlin.collections.Map callableIdIfNonLocal = /Outer.A.map KtFunctionLikeSignature: diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java index 56fa007b4fd..df4ac117c0a 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java @@ -12540,6 +12540,12 @@ public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDia runTest("compiler/testData/diagnostics/tests/generics/localClassTypeRefWithTypeParameterFromFunction.kt"); } + @Test + @TestMetadata("outerTypeParametersInNestedClasses.kt") + public void testOuterTypeParametersInNestedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt"); + } + @Test @TestMetadata("Projections.kt") public void testProjections() throws Exception { diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java index d56c6d201ce..e8e5cd15f19 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java @@ -12540,6 +12540,12 @@ public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated runTest("compiler/testData/diagnostics/tests/generics/localClassTypeRefWithTypeParameterFromFunction.kt"); } + @Test + @TestMetadata("outerTypeParametersInNestedClasses.kt") + public void testOuterTypeParametersInNestedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt"); + } + @Test @TestMetadata("Projections.kt") public void testProjections() throws Exception { diff --git a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.fir.txt b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.fir.txt index 8906e27d0da..a1cfe1986f0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.fir.txt +++ b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.fir.txt @@ -38,7 +38,7 @@ FILE: typeParameterVsNested.kt public final class Some : R|test/My.T| { public constructor(): R|test/My.Some| { - super() + super() } } diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java index 2c78378eb9f..e097620af2e 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java @@ -12540,6 +12540,12 @@ public class FirLightTreeOldFrontendDiagnosticsTestGenerated extends AbstractFir runTest("compiler/testData/diagnostics/tests/generics/localClassTypeRefWithTypeParameterFromFunction.kt"); } + @Test + @TestMetadata("outerTypeParametersInNestedClasses.kt") + public void testOuterTypeParametersInNestedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt"); + } + @Test @TestMetadata("Projections.kt") public void testProjections() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java index 7cf9bc81146..54b222a6f7f 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java @@ -12546,6 +12546,12 @@ public class FirPsiOldFrontendDiagnosticsTestGenerated extends AbstractFirPsiDia runTest("compiler/testData/diagnostics/tests/generics/localClassTypeRefWithTypeParameterFromFunction.kt"); } + @Test + @TestMetadata("outerTypeParametersInNestedClasses.kt") + public void testOuterTypeParametersInNestedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt"); + } + @Test @TestMetadata("Projections.kt") public void testProjections() throws Exception { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPropertyAccessorsTypesChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPropertyAccessorsTypesChecker.kt index a8aeb175e52..401d73fd717 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPropertyAccessorsTypesChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPropertyAccessorsTypesChecker.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isAbstract import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.types.ConeErrorType import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.hasError import org.jetbrains.kotlin.fir.types.isUnit object FirPropertyAccessorsTypesChecker : FirPropertyChecker() { @@ -99,7 +100,7 @@ object FirPropertyAccessorsTypesChecker : FirPropertyChecker() { return } - if (valueSetterType != propertyType) { + if (valueSetterType != propertyType && !valueSetterType.hasError()) { reporter.reportOn(valueSetterTypeSource, FirErrors.WRONG_SETTER_PARAMETER_TYPE, propertyType, valueSetterType, context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirWhenConditionChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirWhenConditionChecker.kt index 649b8ed8eed..036223585ab 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirWhenConditionChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirWhenConditionChecker.kt @@ -6,16 +6,15 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.checkCondition import org.jetbrains.kotlin.fir.analysis.checkers.classKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol -import org.jetbrains.kotlin.fir.expressions.unwrapSmartcastExpression import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneType @@ -58,7 +57,8 @@ object FirWhenConditionChecker : FirWhenExpressionChecker() { } } is FirTypeOperatorCall -> { - if (!checkedTypes.add(condition.conversionTypeRef.coneType to condition.operation)) { + val coneType = condition.conversionTypeRef.coneType + if (!checkedTypes.add(coneType to condition.operation)) { reporter.reportOn(condition.conversionTypeRef.source, FirErrors.DUPLICATE_LABEL_IN_WHEN, context) } } diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt index 98adb196582..485e82f3648 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt +++ b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt @@ -131,3 +131,8 @@ fun ConeKotlinType.renderReadableWithFqNames(): String { return builder.toString() } +fun ConeKotlinType.hasError(): Boolean = when (this) { + is ConeErrorType -> true + is ConeFlexibleType -> lowerBound.hasError() || upperBound.hasError() + else -> typeArguments.any { it is ConeKotlinType && it.hasError() } +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt index 28f8653dee9..c80ea7f07a7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers -import kotlinx.collections.immutable.toImmutableList +import kotlinx.collections.immutable.* import org.jetbrains.kotlin.KtFakeSourceElementKind import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.FirSession @@ -13,6 +13,8 @@ import org.jetbrains.kotlin.fir.correspondingProperty import org.jetbrains.kotlin.fir.copyWithNewSourceKind import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isFromVararg +import org.jetbrains.kotlin.fir.declarations.utils.isInner +import org.jetbrains.kotlin.fir.declarations.utils.isLocal import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguouslyResolvedAnnotationFromPlugin @@ -62,8 +64,16 @@ open class FirTypeResolveTransformer( initialCurrentFile: FirFile? = null, private val classDeclarationsStack: ArrayDeque = ArrayDeque() ) : FirAbstractTreeTransformer(FirResolvePhase.TYPES) { - private val scopes = mutableListOf() - private val towerScope = scopes.asReversed() + /** + * All current scopes sorted from outermost to innermost. + */ + private var scopes = initialScopes.asReversed().toPersistentList() + + /** + * Scopes that are accessible statically, i.e. [scopes] minus type parameter scopes. + */ + private var staticScopes = scopes + private var currentDeclaration: FirDeclaration? = null private inline fun withDeclaration(declaration: FirDeclaration, crossinline action: () -> T): T { @@ -76,10 +86,6 @@ open class FirTypeResolveTransformer( } } - init { - scopes.addAll(initialScopes.asReversed()) - } - private val typeResolverTransformer: FirSpecificTypeResolverTransformer = FirSpecificTypeResolverTransformer(session) private var currentFile: FirFile? = initialCurrentFile @@ -87,7 +93,7 @@ open class FirTypeResolveTransformer( checkSessionConsistency(file) currentFile = file return withScopeCleanup { - scopes.addAll(createImportingScopes(file, session, scopeSession)) + addScopes(createImportingScopes(file, session, scopeSession)) super.transformFile(file, data) } } @@ -252,9 +258,18 @@ open class FirTypeResolveTransformer( override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): FirResolvedTypeRef { return typeResolverTransformer.withFile(currentFile) { + val scopes = scopes + // optimized implementation of reversed Iterable on top of PersistentList + val reversedScopes = object : Iterable { + override fun iterator() = object : Iterator { + private val iter = scopes.listIterator(scopes.size) + override fun hasNext() = iter.hasPrevious() + override fun next() = iter.previous() + } + } typeRef.transform( typeResolverTransformer, - ScopeClassDeclaration(towerScope, classDeclarationsStack, containerDeclaration = currentDeclaration) + ScopeClassDeclaration(reversedScopes, classDeclarationsStack, containerDeclaration = currentDeclaration) ) } } @@ -322,13 +337,14 @@ open class FirTypeResolveTransformer( } private inline fun withScopeCleanup(crossinline l: () -> T): T { - val sizeBefore = scopes.size + val scopesBefore = scopes + val staticScopesBefore = staticScopes + val result = l() - val size = scopes.size - assert(size >= sizeBefore) - repeat(size - sizeBefore) { - scopes.removeAt(scopes.lastIndex) - } + + scopes = scopesBefore + staticScopes = staticScopesBefore + return result } @@ -337,21 +353,25 @@ open class FirTypeResolveTransformer( data: Any? ): FirStatement { - withScopeCleanup { - firClass.transformAnnotations(this, null) - - if (firClass is FirRegularClass) { - firClass.addTypeParametersScope() - } - - // ConstructedTypeRef should be resolved only with type parameters, but not with nested classes and classes from supertypes - for (constructor in firClass.declarations.filterIsInstance()) { - constructor.delegatedConstructor?.let(this::resolveConstructedTypeRefForDelegatedConstructorCall) - } - - } - return withScopeCleanup { + // Remove type parameter scopes for classes that are neither inner nor local + if (!firClass.isInner && !firClass.isLocal) { + this.scopes = staticScopes + } + + withScopeCleanup { + firClass.transformAnnotations(this, null) + + if (firClass is FirRegularClass) { + firClass.addTypeParametersScope() + } + + // ConstructedTypeRef should be resolved only with type parameters, but not with nested classes and classes from supertypes + for (constructor in firClass.declarations.filterIsInstance()) { + constructor.delegatedConstructor?.let(this::resolveConstructedTypeRefForDelegatedConstructorCall) + } + } + // ? Is it Ok to use original file session here ? val superTypes = lookupSuperTypes( firClass, @@ -360,19 +380,26 @@ open class FirTypeResolveTransformer( substituteTypes = true, useSiteSession = session ).asReversed() + + val scopesToAdd = mutableListOf() + for (superType in superTypes) { superType.lookupTag.getNestedClassifierScope(session, scopeSession)?.let { nestedClassifierScope -> val scope = nestedClassifierScope.wrapNestedClassifierScopeWithSubstitutionForSuperType(superType, session) - scopes.add(scope) + scopesToAdd.add(scope) } } - session.nestedClassifierScope(firClass)?.let(scopes::add) + session.nestedClassifierScope(firClass)?.let(scopesToAdd::add) if (firClass is FirRegularClass) { val companionObject = firClass.companionObjectSymbol?.fir if (companionObject != null) { - session.nestedClassifierScope(companionObject)?.let(scopes::add) + session.nestedClassifierScope(companionObject)?.let(scopesToAdd::add) } + + addScopes(scopesToAdd) firClass.addTypeParametersScope() + } else { + addScopes(scopesToAdd) } // Note that annotations are still visited here @@ -393,10 +420,18 @@ open class FirTypeResolveTransformer( private fun FirMemberDeclaration.addTypeParametersScope() { if (typeParameters.isNotEmpty()) { - scopes.add(FirMemberTypeParameterScope(this)) + scopes = scopes.add(FirMemberTypeParameterScope(this)) } } + private fun addScopes(list: List) { + // small optimization to skip unnecessary allocations + val scopesAreTheSame = scopes === staticScopes + + scopes = scopes.addAll(list) + staticScopes = if (scopesAreTheSame) scopes else staticScopes.addAll(list) + } + /** * In a scenario like * diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt index 66bc06c12fd..cc18c6c1c53 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ScopeClassDeclaration.kt @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.scopes.FirScope data class ScopeClassDeclaration( - val scopes: List, + val scopes: Iterable, val containingDeclarations: List, val topContainer: FirDeclaration? = null, val containerDeclaration: FirDeclaration? = null, diff --git a/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.fir.kt b/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.fir.kt deleted file mode 100644 index 16e34ac02d3..00000000000 --- a/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.fir.kt +++ /dev/null @@ -1,104 +0,0 @@ -// !LANGUAGE: +FunctionalInterfaceConversion - -fun interface Good { - fun invoke() -} - -fun interface Foo1 - -fun interface Foo2 { - -} - -fun interface Foo3 { - fun foo() - fun bar() -} - -interface BaseWithSAM { - fun base() -} - -fun interface Foo4 : BaseWithSAM { - fun oneMore() -} - -fun interface Foo4WithDefault : BaseWithSAM { - fun oneMore() {} -} - -interface BaseWithDefault { - fun def() {} -} - -fun interface Foo4WithBaseDefault : BaseWithDefault { - fun oneMore() -} - -fun interface GoodWithBase : BaseWithSAM - -fun interface Foo5 { - val prop: Int -} - -fun interface Foo6 { - fun foo() - val prop: Int -} - -fun interface Foo7 : BaseWithSAM { - val prop: Int -} - -fun interface GoodWithPropAndBase : BaseWithSAM { - val prop: Int get() = 42 -} - -fun interface Foo8 { - fun invoke(x: T) -} - -fun interface GoodGeneric { - fun invoke(x: T) -} - -interface BaseWithGeneric { - fun invoke(x: T) -} - -fun interface Foo9 : BaseWithGeneric - -fun interface GoodExtensionGeneric : GoodGeneric - -fun interface GoodSuspend { - suspend fun invoke() -} - -class WithNestedFun { - fun interface NestedSimple - - fun interface GoodFun { - fun invoke() - } - - fun interface NestedFun { - fun inovke(element: K) - } -} - -fun local() { - fun interface LocalFun { - fun invoke(element: T) - } -} - -fun interface WithDefaultValue { - fun invoke(s: String = "") -} - -interface BaseWithDefaultValue { - fun invoke(s: String = "") -} - -fun interface DeriveDefault : BaseWithDefaultValue - diff --git a/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt b/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt index 18071309679..75e012d1abe 100644 --- a/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt +++ b/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !LANGUAGE: +FunctionalInterfaceConversion fun interface Good { diff --git a/compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.fir.kt b/compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.fir.kt new file mode 100644 index 00000000000..bbea1438f29 --- /dev/null +++ b/compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.fir.kt @@ -0,0 +1,39 @@ +// SKIP_TXT + +class Foo { + companion object { + fun foo(arg: T) {} + } + + object O { + fun foo(arg: T) {} + } + + class Nested { + fun foo(arg: T) {} + } + + inner class Inner { + fun foo(arg1: T, arg2: R) {} + + class InnerNested { + fun foo(arg1: T, arg2: R) {} + } + } + + enum class E { + ; + + fun foo(arg: T) {} + } + + val obj = object { + fun foo(arg: T) {} + } + + fun bar() { + class Local { + fun baz(arg1: T, arg2: R) {} + } + } +} diff --git a/compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt b/compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt new file mode 100644 index 00000000000..10786c1eff9 --- /dev/null +++ b/compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt @@ -0,0 +1,39 @@ +// SKIP_TXT + +class Foo { + companion object { + fun foo(arg: T) {} + } + + object O { + fun foo(arg: T) {} + } + + class Nested { + fun foo(arg: T) {} + } + + inner class Inner { + fun foo(arg1: T, arg2: R) {} + + class InnerNested { + fun foo(arg1: T, arg2: R) {} + } + } + + enum class E { + ; + + fun foo(arg: T) {} + } + + val obj = object { + fun foo(arg: T) {} + } + + fun bar() { + class Local { + fun baz(arg1: T, arg2: R) {} + } + } +} diff --git a/compiler/testData/diagnostics/tests/inner/outerGenericParam.fir.kt b/compiler/testData/diagnostics/tests/inner/outerGenericParam.fir.kt index 78778d830f4..2a707a5c6f3 100644 --- a/compiler/testData/diagnostics/tests/inner/outerGenericParam.fir.kt +++ b/compiler/testData/diagnostics/tests/inner/outerGenericParam.fir.kt @@ -1,6 +1,6 @@ class Outer { class Nested { - fun foo(t: T) = t + fun foo(t: T) = t } class Nested2 { @@ -10,4 +10,4 @@ class Outer { inner class Inner { fun foo(t: T) = t } -} \ No newline at end of file +} 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 3ddf58dba1d..5f6f7433c6b 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 @@ -12546,6 +12546,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/generics/localClassTypeRefWithTypeParameterFromFunction.kt"); } + @Test + @TestMetadata("outerTypeParametersInNestedClasses.kt") + public void testOuterTypeParametersInNestedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/outerTypeParametersInNestedClasses.kt"); + } + @Test @TestMetadata("Projections.kt") public void testProjections() throws Exception { diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.1.fir.kt index ad16d231f7b..98e3d23ce5b 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.1.fir.kt @@ -4,24 +4,24 @@ // TESTCASE NUMBER: 1 class Case1() { - class A(t: T) - class B(x: List) - class C(c: () -> T) - class E(n: Nothing, t: T) + class A(t: T) + class B(x: List<T>) + class C(c: () -> T) + class E(n: Nothing, t: T) } // TESTCASE NUMBER: 2 class Case2() { - data class A(t: T) - data class B(x: List) - data class C(c: () -> T) - data class E(n: Nothing, t: T) + data class A(t: T) + data class B(x: List<T>) + data class C(c: () -> T) + data class E(n: Nothing, t: T) } // TESTCASE NUMBER: 3 class Case3() { - enum class A(t: T) - enum class B(x: List) - enum class C(c: () -> T) - enum class E(n: Nothing, t: T) + enum class A(t: T) + enum class B(x: List<T>) + enum class C(c: () -> T) + enum class E(n: Nothing, t: T) } diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.2.fir.kt index 15e6061f61d..48ae7a72616 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.2.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.2.fir.kt @@ -13,8 +13,8 @@ data class F(t: T) // TESTCASE NUMBER: 2 class Case2() { - data class A(t: T) - data class B(x: List) - data class C(c: () -> T) - data class E(n: Nothing, t: T) + data class A(t: T) + data class B(x: List<T>) + data class C(c: () -> T) + data class E(n: Nothing, t: T) } diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/2.1.fir.kt index 151b6c3dfb7..6eac58f8ce3 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/2.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/2.1.fir.kt @@ -4,8 +4,8 @@ // TESTCASE NUMBER: 1 class Case1() { - class A(val t: T) - class B(val x: List) - class C(val c: () -> T) - class E(val n: Nothing, val t: T) + class A(val t: T) + class B(val x: List<T>) + class C(val c: () -> T) + class E(val n: Nothing, val t: T) } diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/3.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/3.1.fir.kt index e868ab102a8..6ace6b97ad9 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/3.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/3.1.fir.kt @@ -4,8 +4,8 @@ // TESTCASE NUMBER: 1 class Case1() { - class A(var t: T) - class B(var x: List) - class C(var c: () -> T) - class E(var n: Nothing, var t: T) + class A(var t: T) + class B(var x: List<T>) + class C(var c: () -> T) + class E(var n: Nothing, var t: T) } diff --git a/compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg/2.1.fir.kt index 3fa5d5b22c0..9c49898f6e4 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg/2.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg/2.1.fir.kt @@ -5,7 +5,7 @@ // TESTCASE NUMBER: 1 class Case1(val x: AT) { - class B(val y: AT) { + class B(val y: AT) { fun case1() { val k: AT } @@ -21,6 +21,6 @@ class Case1(val x: AT) { } class D() { - fun case1(x: Any) : AT = TODO() + fun case1(x: Any) : AT = TODO() } }