From 3b739d9a44dd74f025f72a88378a4a9c38d76e28 Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Thu, 22 Dec 2022 14:45:59 +0100 Subject: [PATCH] [SLC] AbstractSymbolLightClassesLoadingTest: generate light class for all compiled classes --- .../AbstractSymbolLightClassesFacadeTest.kt | 6 +- .../AbstractSymbolLightClassesLoadingTest.kt | 6 +- ...AbstractSymbolLightClassesParentingTest.kt | 2 +- ...AbstractSymbolLightClassesStructureTest.kt | 2 +- .../base/AbstractSymbolLightClassesTest.kt | 2 +- .../AbstractSymbolLightClassesTestBase.kt | 3 +- .../LateinitProperties.lib.java | 57 ++++++++++ ...ationWithSetParamPropertyModifier.lib.java | 3 - .../lightClassByPsi/classModifiers.lib.java | 48 ++++++++ .../lightClassByPsi/constructors.lib.java | 55 +++++++++ .../lightClassByPsi/coroutines.lib.java | 30 +++++ .../delegatesWithAnnotations.lib.java | 30 +++++ .../jvmWildcardAnnotations.lib.java | 67 +++++++++++ .../lightClassByPsi/throwsAnnotation.lib.java | 12 ++ .../lightClassByPsi/typeAliases.lib.java | 17 +++ .../wildcardOptimization.lib.java | 105 ++++++++++++++++++ 16 files changed, 430 insertions(+), 15 deletions(-) delete mode 100644 compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.lib.java diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesFacadeTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesFacadeTest.kt index d128fb56979..ce920f308a6 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesFacadeTest.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesFacadeTest.kt @@ -23,7 +23,7 @@ abstract class AbstractSymbolLightClassesFacadeTest( override val currentExtension: String, override val stopIfCompilationErrorDirectivePresent: Boolean, ) : AbstractSymbolLightClassesTestBase(configurator) { - override fun getRenderResult(ktFile: KtFile, testDataFile: Path, module: TestModule, project: Project): String { + override fun getRenderResult(ktFile: KtFile, ktFiles: List, testDataFile: Path, module: TestModule, project: Project): String { val lightClasses = getFacades(project) if (lightClasses.isEmpty()) return LightClassTestCommon.NOT_GENERATED_DIRECTIVE return withExtendedTypeRenderer((testDataFile)) { @@ -37,8 +37,6 @@ abstract class AbstractSymbolLightClassesFacadeTest( val kotlinAsJavaSupport = KotlinAsJavaSupport.getInstance(project) val scope = GlobalSearchScope.allScope(project) val facades = kotlinAsJavaSupport.getFacadeNames(FqName.ROOT, scope).sorted() - return facades - .flatMap { facadeName -> kotlinAsJavaSupport.getFacadeClasses(FqName(facadeName), scope) } - .filterIsInstance() + return facades.flatMap { facadeName -> kotlinAsJavaSupport.getFacadeClasses(FqName(facadeName), scope) } } } \ No newline at end of file diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesLoadingTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesLoadingTest.kt index 5ffc618085d..37f97d171b5 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesLoadingTest.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesLoadingTest.kt @@ -10,10 +10,8 @@ import com.intellij.psi.PsiClass import com.intellij.psi.SyntaxTraverser import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator import org.jetbrains.kotlin.asJava.* -import org.jetbrains.kotlin.asJava.classes.KtLightClass import org.jetbrains.kotlin.light.classes.symbol.base.service.withExtendedTypeRenderer import org.jetbrains.kotlin.psi.KtClassOrObject -import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.model.TestModule import java.nio.file.Path @@ -24,8 +22,8 @@ abstract class AbstractSymbolLightClassesLoadingTest( override val stopIfCompilationErrorDirectivePresent: Boolean, ) : AbstractSymbolLightClassesTestBase(configurator) { - override fun getRenderResult(ktFile: KtFile, testDataFile: Path, module: TestModule, project: Project): String { - val lightClasses = getLightClassesFromFile(ktFile, project) + override fun getRenderResult(ktFile: KtFile, ktFiles: List, testDataFile: Path, module: TestModule, project: Project): String { + val lightClasses = ktFiles.flatMap { getLightClassesFromFile(it, project) } if (lightClasses.isEmpty()) return LightClassTestCommon.NOT_GENERATED_DIRECTIVE return withExtendedTypeRenderer(testDataFile) { lightClasses.joinToString("\n\n") { it.renderClass() } diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTest.kt index bb6104a210e..82e977fa13c 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTest.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTest.kt @@ -33,7 +33,7 @@ abstract class AbstractSymbolLightClassesParentingTest( lightClass?.accept(createLightAnnotationVisitor(testServices.assertions)) } - override fun getRenderResult(ktFile: KtFile, testDataFile: Path, module: TestModule, project: Project): String { + override fun getRenderResult(ktFile: KtFile, ktFiles: List, testDataFile: Path, module: TestModule, project: Project): String { throw IllegalStateException("This test is not rendering light elements") } diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureTest.kt index f6f3489bcf9..31345078880 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureTest.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureTest.kt @@ -180,7 +180,7 @@ abstract class AbstractSymbolLightClassesStructureTest( appendLine() } - override fun getRenderResult(ktFile: KtFile, testDataFile: Path, module: TestModule, project: Project): String { + override fun getRenderResult(ktFile: KtFile, ktFiles: List, testDataFile: Path, module: TestModule, project: Project): String { throw UnsupportedOperationException() } } diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTest.kt index eedcd67b32c..09e9a1b92ee 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTest.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTest.kt @@ -17,7 +17,7 @@ abstract class AbstractSymbolLightClassesTest( override val currentExtension: String, override val stopIfCompilationErrorDirectivePresent: Boolean, ) : AbstractSymbolLightClassesTestBase(configurator) { - override fun getRenderResult(ktFile: KtFile, testDataFile: Path, module: TestModule, project: Project): String { + override fun getRenderResult(ktFile: KtFile, ktFiles: List, testDataFile: Path, module: TestModule, project: Project): String { return LightClassTestCommon.getActualLightClassText( testDataFile.toFile(), { fqName -> findLightClass(fqName, project) }, diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt index c47677d1a79..d94e15e82fd 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt @@ -65,7 +65,7 @@ abstract class AbstractSymbolLightClassesTestBase( val project = ktFile.project ignoreExceptionIfIgnoreFirPresent(module) { - val actual = getRenderResult(ktFile, testDataPath, module, project).cleanup() + val actual = getRenderResult(ktFile, ktFiles, testDataPath, module, project).cleanup() compareResults(testServices, actual) removeIgnoreFir(module) removeDuplicatedFirJava(testServices) @@ -82,6 +82,7 @@ abstract class AbstractSymbolLightClassesTestBase( protected abstract fun getRenderResult( ktFile: KtFile, + ktFiles: List, testDataFile: Path, module: TestModule, project: Project diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.lib.java index 9be973fc9c3..0b83ae3cf81 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.lib.java @@ -39,3 +39,60 @@ public static final class Companion /* KotlinClass.Companion*/ { public final void setCompanionLateinitVariable(@org.jetbrains.annotations.NotNull() Custom);// setCompanionLateinitVariable(Custom) } + +public final class Custom /* Custom*/ { + public Custom();// .ctor() + +} + +public final class LateinitPropertiesKt /* LateinitPropertiesKt*/ { + public static Custom topLevelLateinit; + + @org.jetbrains.annotations.NotNull() + public static final Custom getTopLevelLateinit();// getTopLevelLateinit() + + public static final void setTopLevelLateinit(@org.jetbrains.annotations.NotNull() Custom);// setTopLevelLateinit(Custom) + +} + +public abstract class AbstractKotlinClass /* AbstractKotlinClass*/ { + @org.jetbrains.annotations.NotNull() + public static final AbstractKotlinClass.Companion Companion; + + public Custom classLateinitVariable; + + public static Custom companionLateinitStaticVariable; + + public static Custom companionLateinitVariable; + + @org.jetbrains.annotations.NotNull() + public final Custom getClassLateinitVariable();// getClassLateinitVariable() + + @org.jetbrains.annotations.NotNull() + public static final Custom getCompanionLateinitStaticVariable();// getCompanionLateinitStaticVariable() + + public AbstractKotlinClass();// .ctor() + + public final void setClassLateinitVariable(@org.jetbrains.annotations.NotNull() Custom);// setClassLateinitVariable(Custom) + + public static final void setCompanionLateinitStaticVariable(@org.jetbrains.annotations.NotNull() Custom);// setCompanionLateinitStaticVariable(Custom) + + + class Companion ... + + } + +public static final class Companion /* AbstractKotlinClass.Companion*/ { + @org.jetbrains.annotations.NotNull() + public final Custom getCompanionLateinitStaticVariable();// getCompanionLateinitStaticVariable() + + @org.jetbrains.annotations.NotNull() + public final Custom getCompanionLateinitVariable();// getCompanionLateinitVariable() + + private Companion();// .ctor() + + public final void setCompanionLateinitStaticVariable(@org.jetbrains.annotations.NotNull() Custom);// setCompanionLateinitStaticVariable(Custom) + + public final void setCompanionLateinitVariable(@org.jetbrains.annotations.NotNull() Custom);// setCompanionLateinitVariable(Custom) + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.lib.java deleted file mode 100644 index 200f7ce1b54..00000000000 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.lib.java +++ /dev/null @@ -1,3 +0,0 @@ -@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) -public abstract @interface Anno /* Anno*/ { -} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.lib.java index 881926311a8..b5352d1ff54 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.lib.java @@ -10,3 +10,51 @@ public static final class Nested /* pkg.Season.Nested*/ extends pkg.Season { public Nested();// .ctor() } + +public class Open /* pkg.Open*/ { + public Open();// .ctor() + + + + + class Private ... + + class Private2 ... + + class StaticInternal ... + + } + +private static final class Private /* pkg.Open.Private*/ extends pkg.Open { + public Private();// .ctor() + +} + +protected final class Private2 /* pkg.Open.Private2*/ { + public Private2();// .ctor() + +} + +public static final class StaticInternal /* pkg.Open.StaticInternal*/ { + public StaticInternal();// .ctor() + +} + +final class TopLevelPrivate /* pkg.TopLevelPrivate*/ { + public TopLevelPrivate();// .ctor() + +} + +public final class OuterInternal /* pkg.OuterInternal*/ { + public OuterInternal();// .ctor() + +} + +public abstract class SealedWithArgs /* pkg.SealedWithArgs*/ { + private final int a; + + private SealedWithArgs(int);// .ctor(int) + + public final int getA();// getA() + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.lib.java index f35bde85211..555b2dede48 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.lib.java @@ -8,3 +8,58 @@ public final class ClassWithPrivateCtor /* ClassWithPrivateCtor*/ { private ClassWithPrivateCtor(java.util.Set);// .ctor(java.util.Set) } + +public final class B /* B*/ { +} + +public final class AAA /* AAA*/ { + public AAA(@org.jetbrains.annotations.NotNull() int[], @org.jetbrains.annotations.NotNull() kotlin.jvm.functions.Function0);// .ctor(int[], kotlin.jvm.functions.Function0) + +} + +public final class Outer /* Outer*/ { + public Outer();// .ctor() + + + + class Inner ... + + class Nested ... + + } + +public final class Inner /* Outer.Inner*/ { + public Inner(int, @org.jetbrains.annotations.NotNull() java.lang.String);// .ctor(int, java.lang.String) + +} + +public static final class Nested /* Outer.Nested*/ { + public Nested();// .ctor() + + public Nested(int, @org.jetbrains.annotations.NotNull() java.lang.String);// .ctor(int, java.lang.String) + +} + +public abstract class A /* A*/ { + @org.jetbrains.annotations.Nullable() + private final java.lang.String x; + + @org.jetbrains.annotations.Nullable() + public final java.lang.String getX();// getX() + + private A(java.lang.String);// .ctor(java.lang.String) + + + class C ... + + } + +public static final class C /* A.C*/ extends A { + public C();// .ctor() + +} + +public final class TestConstructor /* TestConstructor*/ { + private TestConstructor(int);// .ctor(int) + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.lib.java index 16397d60b63..2fc31a01f24 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.lib.java @@ -3,3 +3,33 @@ public abstract interface Base /* Base*/ { public abstract java.lang.Object foo(@org.jetbrains.annotations.NotNull() kotlin.coroutines.Continuation);// foo(kotlin.coroutines.Continuation) } + +public final class Derived /* Derived*/ implements Base { + @org.jetbrains.annotations.Nullable() + public java.lang.Object foo(@org.jetbrains.annotations.NotNull() kotlin.coroutines.Continuation);// foo(kotlin.coroutines.Continuation) + + public Derived();// .ctor() + +} + +public final class Foo /* Foo*/ { + @org.jetbrains.annotations.Nullable() + public final java.lang.Object doSomething(@org.jetbrains.annotations.NotNull() Foo, @org.jetbrains.annotations.NotNull() kotlin.coroutines.Continuation);// doSomething(Foo, kotlin.coroutines.Continuation) + + public Foo();// .ctor() + +} + +public final class Bar /* Bar*/ { + public Bar();// .ctor() + + public final void async(@org.jetbrains.annotations.NotNull() kotlin.jvm.functions.Function1, ? extends java.lang.Object>);// async(kotlin.jvm.functions.Function1, ? extends java.lang.Object>) + +} + +public final class Boo /* Boo*/ { + private final java.lang.Object doSomething(Foo, kotlin.coroutines.Continuation);// doSomething(Foo, kotlin.coroutines.Continuation) + + public Boo();// .ctor() + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.lib.java index 1c0ffab33b6..9d2fa5bff7f 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.lib.java @@ -3,3 +3,33 @@ public abstract @interface SimpleAnn /* SimpleAnn*/ { public abstract java.lang.String value();// value() } + +@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +public abstract @interface Ann /* Ann*/ { + public abstract SimpleAnn[] t();// t() + + public abstract int x();// x() + + public abstract java.lang.Class z();// z() + + public abstract java.lang.Class[] e();// e() + + public abstract java.lang.String y();// y() + + public abstract kotlin.DeprecationLevel depr();// depr() + +} + +public abstract interface Base /* Base*/ { + @Ann(x = 1, y = "134", z = java.lang.String.class, e = {int.class, double.class}, depr = kotlin.DeprecationLevel.WARNING, t = {@SimpleAnn("243"), @SimpleAnn("4324")}) + public abstract void foo(@Ann(x = 2, y = "324", z = Ann.class, e = {byte.class, Base.class}, depr = kotlin.DeprecationLevel.WARNING, t = {@SimpleAnn("687"), @SimpleAnn("78")}) @org.jetbrains.annotations.NotNull() java.lang.String);// foo(java.lang.String) + +} + +public final class Derived /* Derived*/ implements Base { + @Ann(x = 1, y = "134", z = java.lang.String.class, e = {int.class, double.class}, depr = kotlin.DeprecationLevel.WARNING, t = {@SimpleAnn("243"), @SimpleAnn("4324")}) + public void foo(@Ann(x = 2, y = "324", z = Ann.class, e = {byte.class, Base.class}, depr = kotlin.DeprecationLevel.WARNING, t = {@SimpleAnn("687"), @SimpleAnn("78")}) @org.jetbrains.annotations.NotNull() java.lang.String);// foo(java.lang.String) + + public Derived(@org.jetbrains.annotations.NotNull() Base);// .ctor(Base) + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.lib.java index 7986c9b542c..79fa1042fb6 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.lib.java @@ -2,3 +2,70 @@ public final class OutPair /* OutPair*/ { public OutPair();// .ctor() } + +public final class In /* In*/ { + public In();// .ctor() + +} + +public class Open /* Open*/ { + public Open();// .ctor() + +} + +public abstract interface B /* B*/ { + @kotlin.jvm.JvmSuppressWildcards(suppress = true) + @org.jetbrains.annotations.NotNull() + public abstract In foo();// foo() + +} + +public final class Container /* Container*/ { + @kotlin.jvm.JvmSuppressWildcards(suppress = false) + @org.jetbrains.annotations.NotNull() + public final Out bar();// bar() + + @kotlin.jvm.JvmSuppressWildcards(suppress = false) + public final int foo(boolean, @org.jetbrains.annotations.NotNull() Out);// foo(boolean, Out) + + @kotlin.jvm.JvmSuppressWildcards(suppress = true) + public final int bar(boolean, @org.jetbrains.annotations.NotNull() In, long);// bar(boolean, In, long) + + @kotlin.jvm.JvmSuppressWildcards(suppress = true) + public final void deepOpen(@org.jetbrains.annotations.NotNull() Out>>);// deepOpen(Out>>) + + @org.jetbrains.annotations.NotNull() + public final OutPair, Out>> falseTrueFalse();// falseTrueFalse() + + @org.jetbrains.annotations.NotNull() + public final OutPair>> combination();// combination() + + public Container();// .ctor() + + public final void simpleIn(@org.jetbrains.annotations.NotNull() In);// simpleIn(In) + + public final void simpleOut(@org.jetbrains.annotations.NotNull() Out);// simpleOut(Out) + +} + +public final class Inv /* Inv*/ { + public Inv();// .ctor() + +} + +public final class Out /* Out*/ { + public Out();// .ctor() + +} + +public abstract interface A /* A*/ { + @kotlin.jvm.JvmSuppressWildcards(suppress = true) + @org.jetbrains.annotations.NotNull() + public abstract Out foo();// foo() + +} + +public final class Final /* Final*/ { + public Final();// .ctor() + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.lib.java index 31ef343640c..50e05208505 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.lib.java @@ -2,3 +2,15 @@ public final class MyException /* MyException*/ extends java.lang.Exception { public MyException();// .ctor() } + +public final class C /* C*/ { + @org.jetbrains.annotations.NotNull() + public final java.lang.String readFile(@org.jetbrains.annotations.NotNull() java.lang.String) throws java.io.IOException, MyException;// readFile(java.lang.String) + + public C() throws java.lang.Exception;// .ctor() + + public C(int) throws java.lang.Exception;// .ctor(int) + + public final void baz() throws java.lang.Throwable;// baz() + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.lib.java index 08acd68fed1..a725bc7a056 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.lib.java @@ -1,2 +1,19 @@ public final class TypeAliasesKt /* TypeAliasesKt*/ { } + +public final class O /* O*/ { + @org.jetbrains.annotations.NotNull() + public static final O INSTANCE; + + @kotlin.jvm.JvmOverloads() + public final void foo();// foo() + + @kotlin.jvm.JvmOverloads() + public final void foo(int);// foo(int) + + @kotlin.jvm.JvmOverloads() + public final void foo(int, @org.jetbrains.annotations.NotNull() java.lang.String);// foo(int, java.lang.String) + + private O();// .ctor() + +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.lib.java index 6394d9d76ef..2f8c8088b19 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.lib.java +++ b/compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.lib.java @@ -2,3 +2,108 @@ public final class Out /* Out*/ { public Out();// .ctor() } + +public class Open /* Open*/ { + public Open();// .ctor() + +} + +public final class OutPair /* OutPair*/ { + public OutPair();// .ctor() + +} + +public final class In /* In*/ { + public In();// .ctor() + +} + +public final class Inv /* Inv*/ { + public Inv();// .ctor() + +} + +public final class Container /* Container*/ { + @org.jetbrains.annotations.NotNull() + public final In notDeepIn();// notDeepIn() + + @org.jetbrains.annotations.NotNull() + public final Inv> skipWildcardsUntilInProjection();// skipWildcardsUntilInProjection() + + @org.jetbrains.annotations.NotNull() + public final Inv>> skipAllInvWildcards();// skipAllInvWildcards() + + @org.jetbrains.annotations.NotNull() + public final Inv>>> skipAllOutInvWildcards();// skipAllOutInvWildcards() + + @org.jetbrains.annotations.NotNull() + public final Out>> skipWildcardsUntilIn0();// skipWildcardsUntilIn0() + + @org.jetbrains.annotations.NotNull() + public final Out>> skipWildcardsUntilIn1();// skipWildcardsUntilIn1() + + @org.jetbrains.annotations.NotNull() + public final Out>>> skipWildcardsUntilIn2();// skipWildcardsUntilIn2() + + public Container();// .ctor() + + public final void typeParameter(@org.jetbrains.annotations.NotNull() Out, @org.jetbrains.annotations.NotNull() In);// typeParameter(Out, In) + + public final void arrayOfOutFinal(@org.jetbrains.annotations.NotNull() Out[]);// arrayOfOutFinal(Out[]) + + public final void arrayOfOutOpen(@org.jetbrains.annotations.NotNull() Out[]);// arrayOfOutOpen(Out[]) + + public final void deepFinal(@org.jetbrains.annotations.NotNull() Out>>);// deepFinal(Out>>) + + public final void deepOpen(@org.jetbrains.annotations.NotNull() Out>>);// deepOpen(Out>>) + + public final void finalClassArgument(@org.jetbrains.annotations.NotNull() Out, @org.jetbrains.annotations.NotNull() In);// finalClassArgument(Out, In) + + public final void inAny(@org.jetbrains.annotations.NotNull() In);// inAny(In) + + public final void inFinal(@org.jetbrains.annotations.NotNull() In);// inFinal(In) + + public final void inOutFinal(@org.jetbrains.annotations.NotNull() In>);// inOutFinal(In>) + + public final void invFinal(@org.jetbrains.annotations.NotNull() Inv);// invFinal(Inv) + + public final void invIn(@org.jetbrains.annotations.NotNull() Out>);// invIn(Out>) + + public final void invInAny(@org.jetbrains.annotations.NotNull() Out>);// invInAny(Out>) + + public final void invInOutFinal(@org.jetbrains.annotations.NotNull() Inv>>);// invInOutFinal(Inv>>) + + public final void invInOutOpen(@org.jetbrains.annotations.NotNull() Inv>>);// invInOutOpen(Inv>>) + + public final void invInv(@org.jetbrains.annotations.NotNull() Out>);// invInv(Out>) + + public final void invOpen(@org.jetbrains.annotations.NotNull() Inv);// invOpen(Inv) + + public final void invOut(@org.jetbrains.annotations.NotNull() Out>);// invOut(Out>) + + public final void invOutFinal(@org.jetbrains.annotations.NotNull() Inv>);// invOutFinal(Inv>) + + public final void invOutFinal(@org.jetbrains.annotations.NotNull() Out>);// invOutFinal(Out>) + + public final void invOutOpen(@org.jetbrains.annotations.NotNull() Inv>);// invOutOpen(Inv>) + + public final void invOutProjectedOutFinal(@org.jetbrains.annotations.NotNull() Inv>);// invOutProjectedOutFinal(Inv>) + + public final void oneArgumentFinal(@org.jetbrains.annotations.NotNull() OutPair);// oneArgumentFinal(OutPair) + + public final void openClassArgument(@org.jetbrains.annotations.NotNull() Out, @org.jetbrains.annotations.NotNull() In);// openClassArgument(Out, In) + + public final void outIn(@org.jetbrains.annotations.NotNull() Out>);// outIn(Out>) + + public final void outInAny(@org.jetbrains.annotations.NotNull() Out>);// outInAny(Out>) + + public final void outOfArrayOpen(@org.jetbrains.annotations.NotNull() Out);// outOfArrayOpen(Out) + + public final void outOfArrayOutOpen(@org.jetbrains.annotations.NotNull() Out);// outOfArrayOutOpen(Out) + +} + +public final class Final /* Final*/ { + public Final();// .ctor() + +}