From b42777a28ce6d0e8afcb0886db18c4e06a20bd4a Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 31 Jan 2013 20:41:37 +0400 Subject: [PATCH 01/38] Remove unused parameters --- .../src/jet/runtime/typeinfo/JetValueParameter.java | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/runtime/src/jet/runtime/typeinfo/JetValueParameter.java b/runtime/src/jet/runtime/typeinfo/JetValueParameter.java index 6f64a6b8036..672a8e7a982 100644 --- a/runtime/src/jet/runtime/typeinfo/JetValueParameter.java +++ b/runtime/src/jet/runtime/typeinfo/JetValueParameter.java @@ -34,21 +34,10 @@ public @interface JetValueParameter { */ String name (); - /** - * @return type projections or empty - */ - JetTypeProjection[] typeProjections() default {}; - - /** - * @deprecated info contained in type field - * @return is this type nullable - */ - boolean nullable () default false; - /** * @return if this parameter has default value */ - boolean hasDefaultValue () default false; + boolean hasDefaultValue() default false; /** * @return if this parameter is receiver From 79e27f2d904f60ea654973e64fd7f26f2192159a Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 31 Jan 2013 21:14:59 +0400 Subject: [PATCH 02/38] Write vararg flag on value parameters --- .../jet/codegen/FunctionCodegen.java | 2 +- .../codegen/ImplementationBodyCodegen.java | 1 + .../JetValueParameterAnnotationWriter.java | 6 +++ .../jet/lang/resolve/java/JvmAbi.java | 2 +- .../jet/lang/resolve/java/JvmStdlibNames.java | 1 + .../java/kt/JetValueParameterAnnotation.java | 9 +++- .../resolver/JavaValueParameterResolver.java | 2 +- compiler/testData/cli/wrongAbiVersion.out | 4 +- .../vararg/ConstructorNonLastVararg.kt | 3 ++ .../vararg/ConstructorNonLastVararg.txt | 5 ++ .../{ => vararg}/ConstructorVararg.kt | 0 .../{ => vararg}/ConstructorVararg.txt | 0 .../loadKotlin/fun/vararg/nonLastVararg.kt | 5 ++ .../loadKotlin/fun/vararg/nonLastVararg.txt | 4 ++ .../LoadCompiledKotlinTestGenerated.java | 48 ++++++++++++++++--- ...esolveNamespaceComparingTestGenerated.java | 48 ++++++++++++++++--- .../runtime/typeinfo/JetValueParameter.java | 8 ++++ 17 files changed, 128 insertions(+), 20 deletions(-) create mode 100644 compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.kt create mode 100644 compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.txt rename compiler/testData/loadKotlin/constructor/{ => vararg}/ConstructorVararg.kt (100%) rename compiler/testData/loadKotlin/constructor/{ => vararg}/ConstructorVararg.txt (100%) create mode 100644 compiler/testData/loadKotlin/fun/vararg/nonLastVararg.kt create mode 100644 compiler/testData/loadKotlin/fun/vararg/nonLastVararg.txt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 53b41a13090..05c56420482 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -47,7 +47,6 @@ import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; @@ -401,6 +400,7 @@ public class FunctionCodegen extends GenerationStateAware { JetValueParameterAnnotationWriter av = JetValueParameterAnnotationWriter.visitParameterAnnotation(mv, i + start); av.writeName(parameterDescriptor.getName().getName()); av.writeHasDefaultValue(parameterDescriptor.declaresDefaultValue()); + av.writeVararg(parameterDescriptor.getVarargElementType() != null); if (kotlinParameterTypes.get(i) != null) { av.writeType(kotlinParameterTypes.get(i + start).getKotlinSignature()); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 54ae7258496..cf38ea75ecd 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -1099,6 +1099,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { JetValueParameterAnnotationWriter.visitParameterAnnotation(mv, i); jetValueParameterAnnotation.writeName(valueParameter.getName().getName()); jetValueParameterAnnotation.writeHasDefaultValue(valueParameter.declaresDefaultValue()); + jetValueParameterAnnotation.writeVararg(valueParameter.getVarargElementType() != null); jetValueParameterAnnotation.writeType(constructorMethod.getKotlinParameterType(i)); jetValueParameterAnnotation.visitEnd(); ++i; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/signature/kotlin/JetValueParameterAnnotationWriter.java b/compiler/backend/src/org/jetbrains/jet/codegen/signature/kotlin/JetValueParameterAnnotationWriter.java index a13bafa074b..b35bee7ed03 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/signature/kotlin/JetValueParameterAnnotationWriter.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/signature/kotlin/JetValueParameterAnnotationWriter.java @@ -58,4 +58,10 @@ public class JetValueParameterAnnotationWriter { av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD, true); } } + + public void writeVararg(boolean vararg) { + if (vararg) { + av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_VARARG, true); + } + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java index ffa5f24f1d8..d2d003e4c6b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java @@ -21,7 +21,7 @@ public class JvmAbi { * This constant is used to identify binary format (class file) versions * If you change class file metadata format and/or naming conventions, please increase this number */ - public static final int VERSION = 0; + public static final int VERSION = 1; public static final String TRAIT_IMPL_CLASS_NAME = "$TImpl"; public static final String TRAIT_IMPL_SUFFIX = "$" + TRAIT_IMPL_CLASS_NAME; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java index 280e7f37c8d..c43b2df3d2f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java @@ -26,6 +26,7 @@ public class JvmStdlibNames { public static final String JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD = "hasDefaultValue"; public static final String JET_VALUE_PARAMETER_TYPE_FIELD = "type"; public static final String JET_VALUE_PARAMETER_RECEIVER_FIELD = "receiver"; + public static final String JET_VALUE_PARAMETER_VARARG = "vararg"; public static final JvmClassName JET_TYPE_PARAMETER = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.JetTypeParameter"); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java index 6d02795b616..322b06d9a2d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java @@ -33,6 +33,7 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper { private String type; private boolean receiver; private boolean hasDefaultValue; + private boolean vararg; private JetValueParameterAnnotation(@Nullable PsiAnnotation psiAnnotation) { super(psiAnnotation); @@ -44,6 +45,7 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper { type = getStringAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD, ""); receiver = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_RECEIVER_FIELD, false); hasDefaultValue = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD, false); + vararg = getBooleanAttribute(JvmStdlibNames.JET_VALUE_PARAMETER_VARARG, false); } @NotNull @@ -67,7 +69,12 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper { checkInitialized(); return hasDefaultValue; } - + + public boolean vararg() { + checkInitialized(); + return vararg; + } + public static JetValueParameterAnnotation get(PsiParameter psiParameter) { final PsiAnnotation annotation = JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_VALUE_PARAMETER.getFqName().getFqName()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java index bc1c021b84e..3c219966e35 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java @@ -76,7 +76,7 @@ public final class JavaValueParameterResolver { } JetType varargElementType; - if (psiType instanceof PsiEllipsisType) { + if (psiType instanceof PsiEllipsisType || parameter.getJetValueParameter().vararg()) { varargElementType = KotlinBuiltIns.getInstance().getArrayElementType(TypeUtils.makeNotNullable(outType)); outType = TypeUtils.makeNotNullable(outType); } diff --git a/compiler/testData/cli/wrongAbiVersion.out b/compiler/testData/cli/wrongAbiVersion.out index 82cacf2a786..efc9f0a0376 100644 --- a/compiler/testData/cli/wrongAbiVersion.out +++ b/compiler/testData/cli/wrongAbiVersion.out @@ -1,4 +1,4 @@ WARNING: $TESTDATA_DIR$/wrongAbiVersion.kt: (3, 9) Parameter 'x' is never used -ERROR: $TESTDATA_DIR$/wrongAbiVersionLib/wrong/WrongPackage.java: (3, 1) Class 'wrong.WrongPackage' was compiled with an incompatible version of Kotlin. Its ABI version is -1, expected ABI version is 0 -ERROR: $TESTDATA_DIR$/wrongAbiVersionLib/ClassWithWrongAbiVersion.java: (3, 1) Class 'ClassWithWrongAbiVersion' was compiled with an incompatible version of Kotlin. Its ABI version is -1, expected ABI version is 0 +ERROR: $TESTDATA_DIR$/wrongAbiVersionLib/wrong/WrongPackage.java: (3, 1) Class 'wrong.WrongPackage' was compiled with an incompatible version of Kotlin. Its ABI version is -1, expected ABI version is 1 +ERROR: $TESTDATA_DIR$/wrongAbiVersionLib/ClassWithWrongAbiVersion.java: (3, 1) Class 'ClassWithWrongAbiVersion' was compiled with an incompatible version of Kotlin. Its ABI version is -1, expected ABI version is 1 COMPILATION_ERROR diff --git a/compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.kt b/compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.kt new file mode 100644 index 00000000000..7cd41fa399a --- /dev/null +++ b/compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.kt @@ -0,0 +1,3 @@ +package test + +class A(vararg a: Int, f: () -> Unit) {} \ No newline at end of file diff --git a/compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.txt b/compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.txt new file mode 100644 index 00000000000..024a6e73bad --- /dev/null +++ b/compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.txt @@ -0,0 +1,5 @@ +package test + +internal final class A { + /*primary*/ public constructor A(/*0*/ vararg a : jet.Int /*jet.IntArray*/, /*1*/ f : () -> Unit) +} diff --git a/compiler/testData/loadKotlin/constructor/ConstructorVararg.kt b/compiler/testData/loadKotlin/constructor/vararg/ConstructorVararg.kt similarity index 100% rename from compiler/testData/loadKotlin/constructor/ConstructorVararg.kt rename to compiler/testData/loadKotlin/constructor/vararg/ConstructorVararg.kt diff --git a/compiler/testData/loadKotlin/constructor/ConstructorVararg.txt b/compiler/testData/loadKotlin/constructor/vararg/ConstructorVararg.txt similarity index 100% rename from compiler/testData/loadKotlin/constructor/ConstructorVararg.txt rename to compiler/testData/loadKotlin/constructor/vararg/ConstructorVararg.txt diff --git a/compiler/testData/loadKotlin/fun/vararg/nonLastVararg.kt b/compiler/testData/loadKotlin/fun/vararg/nonLastVararg.kt new file mode 100644 index 00000000000..a87ccc03975 --- /dev/null +++ b/compiler/testData/loadKotlin/fun/vararg/nonLastVararg.kt @@ -0,0 +1,5 @@ +package test + +fun f(vararg t: Int, f: () -> Unit) {} + +fun f(vararg t: String, f: () -> Unit) {} \ No newline at end of file diff --git a/compiler/testData/loadKotlin/fun/vararg/nonLastVararg.txt b/compiler/testData/loadKotlin/fun/vararg/nonLastVararg.txt new file mode 100644 index 00000000000..189d72e9b05 --- /dev/null +++ b/compiler/testData/loadKotlin/fun/vararg/nonLastVararg.txt @@ -0,0 +1,4 @@ +package test + +internal fun f(/*0*/ vararg t : jet.String /*jet.Array*/, /*1*/ f : () -> Unit) : Unit +internal fun f(/*0*/ vararg t : jet.Int /*jet.IntArray*/, /*1*/ f : () -> Unit) : Unit diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java index d9f5029d036..cfa2bef52a6 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java @@ -256,6 +256,7 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT } @TestMetadata("compiler/testData/loadKotlin/constructor") + @InnerTestClasses({Constructor.Vararg.class}) public static class Constructor extends AbstractLoadCompiledKotlinTest { public void testAllFilesPresentInConstructor() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/constructor"), "kt", true); @@ -286,11 +287,6 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT doTest("compiler/testData/loadKotlin/constructor/ConstructorCollectionParameter.kt"); } - @TestMetadata("ConstructorVararg.kt") - public void testConstructorVararg() throws Exception { - doTest("compiler/testData/loadKotlin/constructor/ConstructorVararg.kt"); - } - @TestMetadata("ConstructorWithTwoDefArgs.kt") public void testConstructorWithTwoDefArgs() throws Exception { doTest("compiler/testData/loadKotlin/constructor/ConstructorWithTwoDefArgs.kt"); @@ -331,6 +327,30 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT doTest("compiler/testData/loadKotlin/constructor/PrivateConstructor1WithParamDefaultValue.kt"); } + @TestMetadata("compiler/testData/loadKotlin/constructor/vararg") + public static class Vararg extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInVararg() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/constructor/vararg"), "kt", true); + } + + @TestMetadata("ConstructorNonLastVararg.kt") + public void testConstructorNonLastVararg() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.kt"); + } + + @TestMetadata("ConstructorVararg.kt") + public void testConstructorVararg() throws Exception { + doTest("compiler/testData/loadKotlin/constructor/vararg/ConstructorVararg.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Constructor"); + suite.addTestSuite(Constructor.class); + suite.addTestSuite(Vararg.class); + return suite; + } } @TestMetadata("compiler/testData/loadKotlin/dataClass") @@ -377,7 +397,7 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT } @TestMetadata("compiler/testData/loadKotlin/fun") - @InnerTestClasses({Fun.GenericWithTypeVariables.class, Fun.GenericWithoutTypeVariables.class, Fun.NonGeneric.class}) + @InnerTestClasses({Fun.GenericWithTypeVariables.class, Fun.GenericWithoutTypeVariables.class, Fun.NonGeneric.class, Fun.Vararg.class}) public static class Fun extends AbstractLoadCompiledKotlinTest { public void testAllFilesPresentInFun() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun"), "kt", true); @@ -567,12 +587,26 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT } + @TestMetadata("compiler/testData/loadKotlin/fun/vararg") + public static class Vararg extends AbstractLoadCompiledKotlinTest { + public void testAllFilesPresentInVararg() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun/vararg"), "kt", true); + } + + @TestMetadata("nonLastVararg.kt") + public void testNonLastVararg() throws Exception { + doTest("compiler/testData/loadKotlin/fun/vararg/nonLastVararg.kt"); + } + + } + public static Test innerSuite() { TestSuite suite = new TestSuite("Fun"); suite.addTestSuite(Fun.class); suite.addTestSuite(GenericWithTypeVariables.class); suite.addTestSuite(GenericWithoutTypeVariables.class); suite.addTestSuite(NonGeneric.class); + suite.addTestSuite(Vararg.class); return suite; } } @@ -952,7 +986,7 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT suite.addTestSuite(Class.class); suite.addTestSuite(ClassFun.class); suite.addTestSuite(ClassObject.class); - suite.addTestSuite(Constructor.class); + suite.addTest(Constructor.innerSuite()); suite.addTestSuite(DataClass.class); suite.addTest(Fun.innerSuite()); suite.addTestSuite(Prop.class); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index e0319a122f7..a43ff7e5b9d 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -258,6 +258,7 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso } @TestMetadata("compiler/testData/loadKotlin/constructor") + @InnerTestClasses({Constructor.Vararg.class}) public static class Constructor extends AbstractLazyResolveNamespaceComparingTest { public void testAllFilesPresentInConstructor() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/constructor"), "kt", true); @@ -288,11 +289,6 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestCheckingPrimaryConstructors("compiler/testData/loadKotlin/constructor/ConstructorCollectionParameter.kt"); } - @TestMetadata("ConstructorVararg.kt") - public void testConstructorVararg() throws Exception { - doTestCheckingPrimaryConstructors("compiler/testData/loadKotlin/constructor/ConstructorVararg.kt"); - } - @TestMetadata("ConstructorWithTwoDefArgs.kt") public void testConstructorWithTwoDefArgs() throws Exception { doTestCheckingPrimaryConstructors("compiler/testData/loadKotlin/constructor/ConstructorWithTwoDefArgs.kt"); @@ -333,6 +329,30 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestCheckingPrimaryConstructors("compiler/testData/loadKotlin/constructor/PrivateConstructor1WithParamDefaultValue.kt"); } + @TestMetadata("compiler/testData/loadKotlin/constructor/vararg") + public static class Vararg extends AbstractLazyResolveNamespaceComparingTest { + public void testAllFilesPresentInVararg() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/constructor/vararg"), "kt", true); + } + + @TestMetadata("ConstructorNonLastVararg.kt") + public void testConstructorNonLastVararg() throws Exception { + doTestCheckingPrimaryConstructors("compiler/testData/loadKotlin/constructor/vararg/ConstructorNonLastVararg.kt"); + } + + @TestMetadata("ConstructorVararg.kt") + public void testConstructorVararg() throws Exception { + doTestCheckingPrimaryConstructors("compiler/testData/loadKotlin/constructor/vararg/ConstructorVararg.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Constructor"); + suite.addTestSuite(Constructor.class); + suite.addTestSuite(Vararg.class); + return suite; + } } @TestMetadata("compiler/testData/loadKotlin/dataClass") @@ -379,7 +399,7 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso } @TestMetadata("compiler/testData/loadKotlin/fun") - @InnerTestClasses({Fun.GenericWithTypeVariables.class, Fun.GenericWithoutTypeVariables.class, Fun.NonGeneric.class}) + @InnerTestClasses({Fun.GenericWithTypeVariables.class, Fun.GenericWithoutTypeVariables.class, Fun.NonGeneric.class, Fun.Vararg.class}) public static class Fun extends AbstractLazyResolveNamespaceComparingTest { public void testAllFilesPresentInFun() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun"), "kt", true); @@ -569,12 +589,26 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso } + @TestMetadata("compiler/testData/loadKotlin/fun/vararg") + public static class Vararg extends AbstractLazyResolveNamespaceComparingTest { + public void testAllFilesPresentInVararg() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun/vararg"), "kt", true); + } + + @TestMetadata("nonLastVararg.kt") + public void testNonLastVararg() throws Exception { + doTestCheckingPrimaryConstructors("compiler/testData/loadKotlin/fun/vararg/nonLastVararg.kt"); + } + + } + public static Test innerSuite() { TestSuite suite = new TestSuite("Fun"); suite.addTestSuite(Fun.class); suite.addTestSuite(GenericWithTypeVariables.class); suite.addTestSuite(GenericWithoutTypeVariables.class); suite.addTestSuite(NonGeneric.class); + suite.addTestSuite(Vararg.class); return suite; } } @@ -954,7 +988,7 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso suite.addTestSuite(Class.class); suite.addTestSuite(ClassFun.class); suite.addTestSuite(ClassObject.class); - suite.addTestSuite(Constructor.class); + suite.addTest(Constructor.innerSuite()); suite.addTestSuite(DataClass.class); suite.addTest(Fun.innerSuite()); suite.addTestSuite(Prop.class); diff --git a/runtime/src/jet/runtime/typeinfo/JetValueParameter.java b/runtime/src/jet/runtime/typeinfo/JetValueParameter.java index 672a8e7a982..ada2cd0da1f 100644 --- a/runtime/src/jet/runtime/typeinfo/JetValueParameter.java +++ b/runtime/src/jet/runtime/typeinfo/JetValueParameter.java @@ -48,4 +48,12 @@ public @interface JetValueParameter { * @return type unless Java type is correct Kotlin type. */ String type() default ""; + + /** + * @return true if this parameter is a vararg + * + * NOTE: a method may have a vararg parameter in Kotlin and not be marked as Opcodes.ACC_VARARGS, e.g. + * fun foo(vararg x: Int, f: () -> Unit) + */ + boolean vararg() default false; } From deb9fce5d5915da1766e5b2173ed8ed788b7b8dc Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 1 Feb 2013 19:27:44 +0400 Subject: [PATCH 03/38] Speed up location of test classes --- .../search/KotlinAnnotatedElementsSearcher.java | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java index c5d7424e6b1..a062226467f 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.plugin.search; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Computable; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiClass; @@ -33,15 +34,18 @@ import com.intellij.psi.util.PsiUtilCore; import com.intellij.util.Processor; import com.intellij.util.indexing.FileBasedIndex; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetAnnotationEntry; +import org.jetbrains.jet.lang.psi.JetClass; +import org.jetbrains.jet.lang.psi.JetDeclaration; +import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; +import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager; +import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCache; import org.jetbrains.jet.plugin.stubindex.JetAnnotationsIndex; import java.util.ArrayList; @@ -70,10 +74,12 @@ public class KotlinAnnotatedElementsSearcher extends AnnotatedElementsSearcher { @Override public void run() { //TODO LazyResolve - AnalyzeExhaust analyzeExhaust = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile((JetFile) elt.getContainingFile()); + Project project = elt.getProject(); + KotlinDeclarationsCache declarations = KotlinCacheManager.getInstance(project).getDeclarationsFromProject(project); + BindingContext context = declarations.getBindingContext(); + JetDeclaration parentOfType = PsiTreeUtil.getParentOfType(elt, JetDeclaration.class); if (parentOfType == null) return; - BindingContext context = analyzeExhaust.getBindingContext(); AnnotationDescriptor annotationDescriptor = context.get(BindingContext.ANNOTATION, (JetAnnotationEntry) elt); if (annotationDescriptor == null) return; From 846d8f65e099569b22521d042fb5c2ff55f88b60 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 28 Jan 2013 18:14:37 +0400 Subject: [PATCH 04/38] Refactoring: use delegation instead of subclassing --- .../lang/resolve/scopes/FilteringScope.java | 49 ++++++++++++------- 1 file changed, 30 insertions(+), 19 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java index a645582cd96..7a1ddc843e3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java @@ -25,22 +25,27 @@ import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; +import java.util.List; -public class FilteringScope extends JetScopeAdapter { - private final Predicate predicate; +public class FilteringScope implements JetScope { + @NotNull private final JetScope workerScope; + @NotNull private final Predicate predicate; - public FilteringScope( - @NotNull JetScope workerScope, - @NotNull Predicate predicate - ) { - super(workerScope); + public FilteringScope(@NotNull JetScope workerScope, @NotNull Predicate predicate) { + this.workerScope = workerScope; this.predicate = predicate; } @NotNull @Override public Collection getFunctions(@NotNull Name name) { - return Collections2.filter(super.getFunctions(name), predicate); + return Collections2.filter(workerScope.getFunctions(name), predicate); + } + + @NotNull + @Override + public DeclarationDescriptor getContainingDeclaration() { + return workerScope.getContainingDeclaration(); } @Nullable @@ -50,56 +55,62 @@ public class FilteringScope extends JetScopeAdapter { @Override public NamespaceDescriptor getNamespace(@NotNull Name name) { - return filterDescriptor(super.getNamespace(name)); + return filterDescriptor(workerScope.getNamespace(name)); } @Override public ClassifierDescriptor getClassifier(@NotNull Name name) { - return filterDescriptor(super.getClassifier(name)); + return filterDescriptor(workerScope.getClassifier(name)); } @Override public ClassDescriptor getObjectDescriptor(@NotNull Name name) { - return filterDescriptor(super.getObjectDescriptor(name)); + return filterDescriptor(workerScope.getObjectDescriptor(name)); } @NotNull @Override public Collection getObjectDescriptors() { - return Collections2.filter(super.getObjectDescriptors(), predicate); + return Collections2.filter(workerScope.getObjectDescriptors(), predicate); } @NotNull @Override public Collection getProperties(@NotNull Name name) { - return Collections2.filter(super.getProperties(name), predicate); + return Collections2.filter(workerScope.getProperties(name), predicate); } @Override public VariableDescriptor getLocalVariable(@NotNull Name name) { - return filterDescriptor(super.getLocalVariable(name)); + return filterDescriptor(workerScope.getLocalVariable(name)); } @NotNull @Override public Collection getAllDescriptors() { - return Collections2.filter(super.getAllDescriptors(), predicate); + return Collections2.filter(workerScope.getAllDescriptors(), predicate); } @NotNull @Override - public Collection getDeclarationsByLabel(LabelName labelName) { - return Collections2.filter(super.getDeclarationsByLabel(labelName), predicate); + public List getImplicitReceiversHierarchy() { + return workerScope.getImplicitReceiversHierarchy(); + } + + @NotNull + @Override + public Collection getDeclarationsByLabel(@NotNull LabelName labelName) { + return Collections2.filter(workerScope.getDeclarationsByLabel(labelName), predicate); } @Override public PropertyDescriptor getPropertyByFieldReference(@NotNull Name fieldName) { - return filterDescriptor(super.getPropertyByFieldReference(fieldName)); + return filterDescriptor(workerScope.getPropertyByFieldReference(fieldName)); } @NotNull @Override public Collection getOwnDeclaredDescriptors() { - return Collections2.filter(super.getOwnDeclaredDescriptors(), predicate); + return Collections2.filter(workerScope.getOwnDeclaredDescriptors(), predicate); } } From c5de948cd3294d2a15a234d71f598e026c3937ca Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 28 Jan 2013 18:20:11 +0400 Subject: [PATCH 05/38] Refactoring: remove warning --- .../jet/lang/resolve/scopes/InnerClassesScopeWrapper.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java index 0740442567b..1b8a6111194 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java @@ -45,10 +45,6 @@ public class InnerClassesScopeWrapper extends AbstractScopeAdapter { return actualScope; } - private boolean isClass(DeclarationDescriptor descriptor) { - return descriptor instanceof ClassDescriptor && !((ClassDescriptor) descriptor).getKind().isObject(); - } - @Override public ClassifierDescriptor getClassifier(@NotNull Name name) { ClassifierDescriptor classifier = actualScope.getClassifier(name); @@ -90,4 +86,8 @@ public class InnerClassesScopeWrapper extends AbstractScopeAdapter { public String toString() { return "Classes from " + actualScope; } + + private static boolean isClass(DeclarationDescriptor descriptor) { + return descriptor instanceof ClassDescriptor && !((ClassDescriptor) descriptor).getKind().isObject(); + } } From 9b807a6c30c810ce99a81df8e116e11204a5e80f Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 28 Jan 2013 18:25:20 +0400 Subject: [PATCH 06/38] Refactoring: move AbstractScopeAdapter to scope package --- .../jet/lang/descriptors/MutableClassDescriptor.java | 6 +----- .../jet/lang/resolve/{ => scopes}/AbstractScopeAdapter.java | 3 +-- .../jet/lang/resolve/scopes/InnerClassesScopeWrapper.java | 1 - .../jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java | 1 - .../jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java | 1 - 5 files changed, 2 insertions(+), 10 deletions(-) rename compiler/frontend/src/org/jetbrains/jet/lang/resolve/{ => scopes}/AbstractScopeAdapter.java (97%) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java index f662b2f3eec..b56a0cd4426 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java @@ -20,14 +20,10 @@ import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetParameter; -import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; +import org.jetbrains.jet.lang.resolve.scopes.*; import java.util.Collections; import java.util.List; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.java similarity index 97% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.java index 6ee44474ab0..2e4137490c6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.java @@ -14,13 +14,12 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.resolve; +package org.jetbrains.jet.lang.resolve.scopes; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; import java.util.Collection; import java.util.List; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java index 1b8a6111194..070d260898f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java @@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; -import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter; import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java index a45d7fb4936..3df901bedca 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.resolve.scopes; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter; public class JetScopeAdapter extends AbstractScopeAdapter { @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java index 170fdc6f54c..752c2937e48 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.resolve.scopes; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter; import org.jetbrains.jet.util.lazy.RecursionIntolerantLazyValue; public class LazyScopeAdapter extends AbstractScopeAdapter { From 2ec9e10f14993e6829b644744aa4aff26323dd75 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 28 Jan 2013 18:52:29 +0400 Subject: [PATCH 07/38] Refactoring: reuse method, remove warnings, don't process descriptors substituted to null twice --- .../lang/resolve/scopes/SubstitutingScope.java | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java index 046aad9cbea..c021571dd7b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java @@ -53,10 +53,13 @@ public class SubstitutingScope implements JetScope { } DeclarationDescriptor substituted = substitutedDescriptors.get(descriptor); - if (substituted == null) { + if (substituted == null && !substitutedDescriptors.containsKey(descriptor)) { substituted = descriptor.substitute(substitutor); + + //noinspection ConstantConditions substitutedDescriptors.put(descriptor, substituted); } + //noinspection unchecked return (D) substituted; } @@ -129,7 +132,7 @@ public class SubstitutingScope implements JetScope { @NotNull @Override - public Collection getDeclarationsByLabel(LabelName labelName) { + public Collection getDeclarationsByLabel(@NotNull LabelName labelName) { throw new UnsupportedOperationException(); // TODO } @@ -142,14 +145,7 @@ public class SubstitutingScope implements JetScope { @Override public Collection getAllDescriptors() { if (allDescriptors == null) { - allDescriptors = Sets.newHashSet(); - for (DeclarationDescriptor descriptor : workerScope.getAllDescriptors()) { - DeclarationDescriptor substitute = substitute(descriptor); -// assert substitute != null : descriptor; - if (substitute != null) { - allDescriptors.add(substitute); - } - } + allDescriptors = substitute(workerScope.getAllDescriptors()); } return allDescriptors; } From 8b60b07cc5fa5c6d34399b8d565692776d9786d8 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 28 Jan 2013 19:06:34 +0400 Subject: [PATCH 08/38] Refactoring: remove warnings --- .../tests/org/jetbrains/jet/resolve/JetResolveTest.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index eb4191c2c0a..faa1833287d 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -55,11 +55,13 @@ import java.util.Map; import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.resolveFakeCall; +@SuppressWarnings("JUnitTestCaseWithNoTests") public class JetResolveTest extends ExtensibleResolveTestCase { private final String path; private final String name; + @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors") public JetResolveTest(String path, String name) { this.path = path; this.name = name; @@ -160,7 +162,10 @@ public class JetResolveTest extends ExtensibleResolveTestCase { } private static String getHomeDirectory() { - return new File(PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class")).getParentFile().getParentFile().getParent(); + String resourceRoot = PathManager.getResourceRoot(JetParsingTest.class, "/org/jetbrains/jet/parsing/JetParsingTest.class"); + assertNotNull(resourceRoot); + + return new File(resourceRoot).getParentFile().getParentFile().getParent(); } @Override From 83bc8d4f213989b2e324eff18895ec0528ec1fb0 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 30 Jan 2013 21:03:08 +0400 Subject: [PATCH 09/38] Centralize and cache creating import directives --- .../di/InjectorForJavaDescriptorResolver.java | 1 - .../di/InjectorForJavaSemanticServices.java | 1 - .../di/InjectorForTopDownAnalyzerForJvm.java | 7 ++- .../resolve/java/AnalyzerFacadeForJVM.java | 16 +++--- .../resolve/java/JavaBridgeConfiguration.java | 32 +++++------- .../jet/analyzer/AnalyzeExhaust.java | 10 ++-- .../jet/di/InjectorForLazyResolve.java | 9 ++++ .../di/InjectorForTopDownAnalyzerBasic.java | 6 +++ .../jet/lang/DefaultModuleConfiguration.java | 27 ++++------ .../jet/lang/ModuleConfiguration.java | 10 ++-- .../jetbrains/jet/lang/psi/JetPsiBuilder.java | 50 +++++++++++++++++++ .../jet/lang/resolve/ImportsResolver.java | 33 ++++++++---- .../jet/lang/resolve/lazy/ScopeProvider.java | 6 ++- .../jet/lang/types/lang/KotlinBuiltIns.java | 15 ++---- .../resolve/lazy/LazyResolveTestUtil.java | 16 +++--- .../injectors/GenerateInjectors.java | 2 + .../libraries/JetSourceNavigationHelper.java | 2 +- .../di/InjectorForTopDownAnalyzerForJs.java | 6 +++ .../k2js/analyze/AnalyzerFacadeForJS.java | 6 +-- .../k2js/analyze/JsConfiguration.java | 25 +++------- 20 files changed, 172 insertions(+), 108 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index dc52473dd14..2bbd6d8cb39 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -93,7 +93,6 @@ public class InjectorForJavaDescriptorResolver { this.javaPropertyResolver = new JavaPropertyResolver(); javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); - javaBridgeConfiguration.setProject(project); this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); this.javaSemanticServices.setPsiClassFinder(psiClassFinder); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 85d4250efc5..74425a00572 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -104,7 +104,6 @@ public class InjectorForJavaSemanticServices { this.javaDescriptorResolver.setPropertiesResolver(javaPropertyResolver); javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); - javaBridgeConfiguration.setProject(project); this.psiClassFinder.setProject(project); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 053e075cbc9..5a1690d9a54 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.psi.JetPsiBuilder; import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; @@ -89,6 +90,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private QualifiedExpressionResolver qualifiedExpressionResolver; private CandidateResolver candidateResolver; private ImportsResolver importsResolver; + private JetPsiBuilder jetPsiBuilder; private ScriptHeaderResolver scriptHeaderResolver; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; @@ -139,6 +141,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.candidateResolver = new CandidateResolver(); this.importsResolver = new ImportsResolver(); + this.jetPsiBuilder = new JetPsiBuilder(); this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); @@ -193,7 +196,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.descriptorResolver.setTypeResolver(typeResolver); this.moduleConfiguration.setJavaSemanticServices(javaSemanticServices); - this.moduleConfiguration.setProject(project); javaDescriptorResolver.setClassResolver(javaClassResolver); javaDescriptorResolver.setConstructorResolver(javaConstructorResolver); @@ -240,9 +242,12 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); + importsResolver.setPsiBuilder(jetPsiBuilder); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); + jetPsiBuilder.setProject(project); + scriptHeaderResolver.setContext(topDownAnalysisContext); scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver); scriptHeaderResolver.setNamespaceFactory(namespaceFactory); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 779a9fd77be..8a37dbdb52c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve.java; import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.google.common.collect.Lists; +import com.google.common.collect.Sets; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; @@ -33,8 +34,6 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetImportDirective; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.lazy.LockBasedStorageManager; @@ -45,9 +44,9 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; +import java.util.LinkedHashSet; import java.util.List; public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @@ -103,13 +102,10 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { ModuleConfiguration moduleConfiguration = new ModuleConfiguration() { @Override - public void addDefaultImports(@NotNull Collection directives) { - final Collection defaultImports = Lists.newArrayList(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS); - defaultImports.addAll(Arrays.asList(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS)); - - for (ImportPath defaultJetImport : defaultImports) { - directives.add(JetPsiFactory.createImportDirective(fileProject, defaultJetImport)); - } + public List getDefaultImports() { + LinkedHashSet imports = Sets.newLinkedHashSet(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS); + imports.addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS); + return Lists.newArrayList(imports); } @Override diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java index 6064b1de51c..3d183a0e7bf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java @@ -16,14 +16,14 @@ package org.jetbrains.jet.lang.resolve.java; -import com.intellij.openapi.project.Project; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetImportDirective; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -31,22 +31,16 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import javax.annotation.PostConstruct; import javax.inject.Inject; -import java.util.Collection; +import java.util.List; +import java.util.Set; public class JavaBridgeConfiguration implements ModuleConfiguration { - public static final ImportPath[] DEFAULT_JAVA_IMPORTS = new ImportPath[] { new ImportPath("java.lang.*") }; + public static final List DEFAULT_JAVA_IMPORTS = ImmutableList.of(new ImportPath("java.lang.*")); - - private Project project; private JavaSemanticServices javaSemanticServices; private ModuleConfiguration delegateConfiguration; - @Inject - public void setProject(@NotNull Project project) { - this.project = project; - } - @Inject public void setJavaSemanticServices(@NotNull JavaSemanticServices javaSemanticServices) { this.javaSemanticServices = javaSemanticServices; @@ -54,17 +48,15 @@ public class JavaBridgeConfiguration implements ModuleConfiguration { @PostConstruct public void init() { - this.delegateConfiguration = DefaultModuleConfiguration.createStandardConfiguration(project); + this.delegateConfiguration = DefaultModuleConfiguration.createStandardConfiguration(); } - - @Override - public void addDefaultImports(@NotNull Collection directives) { - for (ImportPath importPath : DEFAULT_JAVA_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, importPath)); - } - delegateConfiguration.addDefaultImports(directives); + public List getDefaultImports() { + Set imports = Sets.newLinkedHashSet(DEFAULT_JAVA_IMPORTS); + imports.addAll(delegateConfiguration.getDefaultImports()); + + return Lists.newArrayList(imports); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java index 63ffd872eaf..3b66448d58b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java @@ -18,21 +18,23 @@ package org.jetbrains.jet.analyzer; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BodiesResolveContext; +import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import java.util.Collection; +import java.util.Collections; +import java.util.List; public class AnalyzeExhaust { private static final ModuleConfiguration ERROR_CONFIGURATION = new ModuleConfiguration() { @Override - public void addDefaultImports(@NotNull Collection directives) { + public List getDefaultImports() { + return Collections.emptyList(); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 1e7945b5077..274b3b610de 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.psi.JetPsiBuilder; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; @@ -45,6 +46,7 @@ public class InjectorForLazyResolve { private ScopeProvider scopeProvider; private AnnotationResolver annotationResolver; private QualifiedExpressionResolver qualifiedExpressionResolver; + private JetPsiBuilder jetPsiBuilder; private CallResolver callResolver; private ArgumentTypeResolver argumentTypeResolver; private CandidateResolver candidateResolver; @@ -65,6 +67,7 @@ public class InjectorForLazyResolve { this.scopeProvider = new ScopeProvider(resolveSession); this.annotationResolver = new AnnotationResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.jetPsiBuilder = new JetPsiBuilder(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); @@ -86,6 +89,8 @@ public class InjectorForLazyResolve { this.annotationResolver.setCallResolver(callResolver); this.annotationResolver.setExpressionTypingServices(expressionTypingServices); + this.jetPsiBuilder.setProject(project); + callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); callResolver.setExpressionTypingServices(expressionTypingServices); @@ -126,4 +131,8 @@ public class InjectorForLazyResolve { return this.qualifiedExpressionResolver; } + public JetPsiBuilder getJetPsiBuilder() { + return this.jetPsiBuilder; + } + } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 35d0b537a9e..03fccadbc3e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.psi.JetPsiBuilder; import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; @@ -71,6 +72,7 @@ public class InjectorForTopDownAnalyzerBasic { private QualifiedExpressionResolver qualifiedExpressionResolver; private CandidateResolver candidateResolver; private ImportsResolver importsResolver; + private JetPsiBuilder jetPsiBuilder; private ScriptHeaderResolver scriptHeaderResolver; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; @@ -106,6 +108,7 @@ public class InjectorForTopDownAnalyzerBasic { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.candidateResolver = new CandidateResolver(); this.importsResolver = new ImportsResolver(); + this.jetPsiBuilder = new JetPsiBuilder(); this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); @@ -180,9 +183,12 @@ public class InjectorForTopDownAnalyzerBasic { importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); + importsResolver.setPsiBuilder(jetPsiBuilder); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); + jetPsiBuilder.setProject(project); + scriptHeaderResolver.setContext(topDownAnalysisContext); scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); scriptHeaderResolver.setNamespaceFactory(namespaceFactory); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java index 1fe95fe0e02..f7058742d4e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java @@ -16,38 +16,33 @@ package org.jetbrains.jet.lang; -import com.intellij.openapi.project.Project; +import com.google.common.collect.ImmutableList; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetImportDirective; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import java.util.Collection; +import java.util.List; public class DefaultModuleConfiguration implements ModuleConfiguration { - public static final ImportPath[] DEFAULT_JET_IMPORTS = new ImportPath[] { - new ImportPath("kotlin.*"), new ImportPath("kotlin.io.*"), new ImportPath("jet.*"), }; + public static final List DEFAULT_JET_IMPORTS = ImmutableList.of( + new ImportPath("kotlin.*"), + new ImportPath("kotlin.io.*"), + new ImportPath("jet.*")); - private final Project project; - - public static DefaultModuleConfiguration createStandardConfiguration(Project project) { - return new DefaultModuleConfiguration(project); + public static DefaultModuleConfiguration createStandardConfiguration() { + return new DefaultModuleConfiguration(); } - private DefaultModuleConfiguration(@NotNull Project project) { - this.project = project; + private DefaultModuleConfiguration() { } @Override - public void addDefaultImports(@NotNull Collection directives) { - for (ImportPath defaultJetImport : DEFAULT_JET_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport)); - } + public List getDefaultImports() { + return DEFAULT_JET_IMPORTS; } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java index d12bc3c89d0..98ab5190355 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java @@ -18,16 +18,18 @@ package org.jetbrains.jet.lang; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import java.util.Collection; +import java.util.Collections; +import java.util.List; public interface ModuleConfiguration { ModuleConfiguration EMPTY = new ModuleConfiguration() { @Override - public void addDefaultImports(@NotNull Collection directives) { + public List getDefaultImports() { + return Collections.emptyList(); } @Override @@ -46,7 +48,7 @@ public interface ModuleConfiguration { } }; - void addDefaultImports(@NotNull Collection directives); + List getDefaultImports(); /** * This method is called every time a namespace descriptor is created. Use it to add extra descriptors to the namespace, e.g. merge a diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java new file mode 100644 index 00000000000..3b189edc4c0 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.psi; + +import com.google.common.collect.Maps; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.ImportPath; + +import javax.inject.Inject; +import java.util.Map; + +public class JetPsiBuilder { + @NotNull + private Project project; + + private final Map importsCache = Maps.newHashMap(); + + @Inject + public void setProject(@NotNull Project project) { + importsCache.clear(); + this.project = project; + } + + public JetImportDirective createImportDirective(@NotNull ImportPath importPath) { + JetImportDirective directive = importsCache.get(importPath); + if (directive != null) { + return directive; + } + + JetImportDirective createdDirective = JetPsiFactory.createImportDirective(project, importPath); + importsCache.put(importPath, createdDirective); + + return createdDirective; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 874519249a4..84b4f3d03ce 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -19,9 +19,12 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -32,9 +35,7 @@ import java.util.Collection; import java.util.List; import java.util.Map; -import static org.jetbrains.jet.lang.diagnostics.Errors.PLATFORM_CLASS_MAPPED_TO_KOTLIN; -import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_HIDDEN_IMPORT; -import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_SIMPLE_IMPORT; +import static org.jetbrains.jet.lang.diagnostics.Errors.*; public class ImportsResolver { @NotNull @@ -45,6 +46,8 @@ public class ImportsResolver { private QualifiedExpressionResolver qualifiedExpressionResolver; @NotNull private BindingTrace trace; + @NotNull + private JetPsiBuilder psiBuilder; @Inject public void setContext(@NotNull TopDownAnalysisContext context) { @@ -66,6 +69,11 @@ public class ImportsResolver { this.qualifiedExpressionResolver = qualifiedExpressionResolver; } + @Inject + public void setPsiBuilder(@NotNull JetPsiBuilder psiBuilder) { + this.psiBuilder = psiBuilder; + } + public void processTypeImports(@NotNull JetScope rootScope) { processImports(true, rootScope); } @@ -86,7 +94,7 @@ public class ImportsResolver { } private void processImportsInFile(boolean classes, WritableScope scope, List directives, JetScope rootScope) { - processImportsInFile(classes, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver); + processImportsInFile(classes, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver, psiBuilder); } public static void processImportsInFile( @@ -96,23 +104,26 @@ public class ImportsResolver { @NotNull JetScope rootScope, @NotNull ModuleConfiguration configuration, @NotNull BindingTrace trace, - @NotNull QualifiedExpressionResolver qualifiedExpressionResolver + @NotNull QualifiedExpressionResolver qualifiedExpressionResolver, + @NotNull JetPsiBuilder psiBuilder ) { Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope); if (!onlyClasses) { namespaceScope.clearImports(); } - Map resolvedDirectives = Maps.newHashMap(); - Collection defaultImportDirectives = Lists.newArrayList(); - configuration.addDefaultImports(defaultImportDirectives); - for (JetImportDirective defaultImportDirective : defaultImportDirectives) { + + for (ImportPath defaultImportPath : configuration.getDefaultImports()) { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create( trace, "transient trace to resolve default imports"); //not to trace errors of default imports + + JetImportDirective defaultImportDirective = psiBuilder.createImportDirective(defaultImportPath); qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, temporaryTrace, configuration, onlyClasses); } + Map resolvedDirectives = Maps.newHashMap(); + for (JetImportDirective importDirective : importDirectives) { Collection descriptors = qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index 2229c530919..8e5160902e5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java @@ -81,7 +81,8 @@ public class ScopeProvider { ImportsResolver.processImportsInFile(true, fileScope, Lists.newArrayList(file.getImportDirectives()), rootPackageDescriptor.getMemberScope(), resolveSession.getModuleConfiguration(), resolveSession.getTrace(), - resolveSession.getInjector().getQualifiedExpressionResolver()); + resolveSession.getInjector().getQualifiedExpressionResolver(), + resolveSession.getInjector().getJetPsiBuilder()); fileScope.changeLockLevel(WritableScope.LockLevel.READING); @@ -121,7 +122,8 @@ public class ScopeProvider { ImportsResolver.processImportsInFile(false, fileMemberScope, Lists.newArrayList(file.getImportDirectives()), rootPackageDescriptor.getMemberScope(), resolveSession.getModuleConfiguration(), resolveSession.getTrace(), - resolveSession.getInjector().getQualifiedExpressionResolver()); + resolveSession.getInjector().getQualifiedExpressionResolver(), + resolveSession.getInjector().getJetPsiBuilder()); fileMemberScope.changeLockLevel(WritableScope.LockLevel.READING); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 0ba6278510f..fb4ea1ae0f6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2012 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -228,7 +228,7 @@ public class KotlinBuiltIns { project, storageManager, builtInsModule, - new SpecialModuleConfiguration(project), + new SpecialModuleConfiguration(), new FileBasedDeclarationProviderFactory(storageManager, files), new Function() { @Override @@ -263,17 +263,12 @@ public class KotlinBuiltIns { private static class SpecialModuleConfiguration implements ModuleConfiguration { - private final Project project; - - private SpecialModuleConfiguration(@NotNull Project project) { - this.project = project; + private SpecialModuleConfiguration() { } @Override - public void addDefaultImports(@NotNull Collection directives) { - for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport)); - } + public List getDefaultImports() { + return DefaultModuleConfiguration.DEFAULT_JET_IMPORTS; } @Override diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index 7e8058fda38..f4d90395eaa 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.google.common.base.Predicate; import com.google.common.base.Predicates; +import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; @@ -33,7 +34,10 @@ import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetNamespaceHeader; +import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap; @@ -44,7 +48,6 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Set; @@ -102,11 +105,10 @@ public class LazyResolveTestUtil { ModuleConfiguration moduleConfiguration = new ModuleConfiguration() { @Override - public void addDefaultImports(@NotNull Collection directives) { - directives.add(JetPsiFactory.createImportDirective(project, new ImportPath("java.lang.*"))); - for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport)); - } + public List getDefaultImports() { + List imports = Lists.newArrayList(new ImportPath("java.lang.*")); + imports.addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS); + return imports; } @Override diff --git a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index 88f51bc9adc..d9e69574a56 100644 --- a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.di.*; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetPsiBuilder; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; @@ -71,6 +72,7 @@ public class GenerateInjectors { generator.addPublicField(ScopeProvider.class); generator.addPublicField(AnnotationResolver.class); generator.addPublicField(QualifiedExpressionResolver.class); + generator.addPublicField(JetPsiBuilder.class); generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", GenerateInjectors.class); } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index eaf405bebab..1168c71498c 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -211,7 +211,7 @@ public class JetSourceNavigationHelper { project, storageManager, new ModuleDescriptor(Name.special("")), - DefaultModuleConfiguration.createStandardConfiguration(project), + DefaultModuleConfiguration.createStandardConfiguration(), providerFactory); for (JetNamedDeclaration candidate : candidates) { diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 0b0cca2f060..a8a208476bb 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.psi.JetPsiBuilder; import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; @@ -71,6 +72,7 @@ public class InjectorForTopDownAnalyzerForJs { private QualifiedExpressionResolver qualifiedExpressionResolver; private CandidateResolver candidateResolver; private ImportsResolver importsResolver; + private JetPsiBuilder jetPsiBuilder; private ScriptHeaderResolver scriptHeaderResolver; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; @@ -106,6 +108,7 @@ public class InjectorForTopDownAnalyzerForJs { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.candidateResolver = new CandidateResolver(); this.importsResolver = new ImportsResolver(); + this.jetPsiBuilder = new JetPsiBuilder(); this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); @@ -180,9 +183,12 @@ public class InjectorForTopDownAnalyzerForJs { importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); + importsResolver.setPsiBuilder(jetPsiBuilder); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); + jetPsiBuilder.setProject(project); + scriptHeaderResolver.setContext(topDownAnalysisContext); scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); scriptHeaderResolver.setNamespaceFactory(namespaceFactory); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index 7612c4ec77e..f53c7da0466 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2012 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -89,7 +89,7 @@ public final class AnalyzerFacadeForJS { new DelegatingBindingTrace(libraryBindingContext, "trace for analyzing library in js"); InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( project, topDownAnalysisParameters, trace, owner, - new JsConfiguration(project, libraryBindingContext)); + new JsConfiguration(libraryBindingContext)); try { Collection allFiles = libraryBindingContext != null ? files : @@ -144,6 +144,6 @@ public final class AnalyzerFacadeForJS { FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); - return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(config.getProject(), null), declarationProviderFactory); + return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(null), declarationProviderFactory); } } diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java b/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java index 788e3d1b009..8f3cfd363b5 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java @@ -16,15 +16,13 @@ package org.jetbrains.k2js.analyze; -import com.intellij.openapi.project.Project; +import com.google.common.collect.ImmutableList; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetImportDirective; -import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; @@ -34,8 +32,6 @@ import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import java.util.Arrays; -import java.util.Collection; import java.util.List; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isRootNamespace; @@ -43,36 +39,31 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isRootNamespace; public class JsConfiguration implements ModuleConfiguration { @NotNull - public static final List DEFAULT_IMPORT_PATHS = Arrays.asList( + public static final List DEFAULT_IMPORT_PATHS = ImmutableList.of( new ImportPath("js.*"), new ImportPath("java.lang.*"), new ImportPath(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName(), true), new ImportPath("kotlin.*")); - @NotNull - private final Project project; /* - * Adds a possibility to inject some preanalyzed files to speed up tests. - * */ + * Adds a possibility to inject some preanalyzed files to speed up tests. + */ @Nullable private final BindingContext preanalyzedContext; - JsConfiguration(@NotNull Project project, @Nullable BindingContext preanalyzedContext) { - this.project = project; + JsConfiguration(@Nullable BindingContext preanalyzedContext) { this.preanalyzedContext = preanalyzedContext; } @Override - public void addDefaultImports(@NotNull Collection directives) { - for (ImportPath path : DEFAULT_IMPORT_PATHS) { - directives.add(JetPsiFactory.createImportDirective(project, path)); - } + public List getDefaultImports() { + return DEFAULT_IMPORT_PATHS; } @Override public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { - DefaultModuleConfiguration.createStandardConfiguration(project) + DefaultModuleConfiguration.createStandardConfiguration() .extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope); // Extend root namespace with standard classes From 70ce304c93db3d0c89afeba2c7a05ced20afb901 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 25 Dec 2012 21:32:14 +0400 Subject: [PATCH 10/38] Store alias name with import path --- .../jetbrains/jet/lang/psi/JetPsiFactory.java | 15 ++--- .../jetbrains/jet/lang/psi/JetPsiUtil.java | 13 +++-- .../jet/lang/resolve/ImportPath.java | 58 +++++++++++++++---- .../jet/util/QualifiedNamesUtil.java | 6 +- .../weigher/JetExplicitlyImportedWeigher.java | 2 +- .../importOptimizer/JetImportOptimizer.java | 8 +-- .../plugin/quickfix/ImportClassAndFunFix.java | 2 +- .../plugin/quickfix/ImportInsertHelper.java | 54 ++++++++--------- 8 files changed, 98 insertions(+), 60 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java index 10fdf5f3349..d4fa6e97162 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java @@ -26,6 +26,7 @@ import com.intellij.util.LocalTimeCounter; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.ImportPath; +import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.plugin.JetFileType; @@ -179,11 +180,6 @@ public class JetPsiFactory { @NotNull public static JetImportDirective createImportDirective(Project project, @NotNull ImportPath importPath) { - return createImportDirective(project, importPath, null); - } - - @NotNull - public static JetImportDirective createImportDirective(Project project, @NotNull ImportPath importPath, @Nullable String aliasName) { if (importPath.fqnPart().isRoot()) { throw new IllegalArgumentException("import path must not be empty"); } @@ -191,12 +187,9 @@ public class JetPsiFactory { StringBuilder importDirectiveBuilder = new StringBuilder("import "); importDirectiveBuilder.append(importPath.getPathStr()); - if (aliasName != null) { - if (aliasName.isEmpty()) { - throw new IllegalArgumentException("Alias must not be empty"); - } - - importDirectiveBuilder.append(" as ").append(aliasName); + Name alias = importPath.getAlias(); + if (alias != null) { + importDirectiveBuilder.append(" as ").append(alias.getName()); } JetFile namespace = createFile(project, importDirectiveBuilder.toString()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index 1eab7e8039f..4a09f41652c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -258,17 +258,22 @@ public class JetPsiUtil { @Nullable @IfNotParsed public static ImportPath getImportPath(JetImportDirective importDirective) { + if (PsiTreeUtil.hasErrorElements(importDirective)) { + return null; + } + final JetExpression importedReference = importDirective.getImportedReference(); if (importedReference == null) { return null; } - if (PsiTreeUtil.hasErrorElements(importedReference)) { - return null; + Name alias = null; + String aliasName = importDirective.getAliasName(); + if (aliasName != null) { + alias = Name.identifier(aliasName); } - final String text = importedReference.getText(); - return new ImportPath(text.replaceAll(" ", "") + (importDirective.isAllUnder() ? ".*" : "")); + return new ImportPath(new FqName(importedReference.getText().replaceAll(" ", "")), importDirective.isAllUnder(), alias); } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java index 47665faed96..8a3b2767337 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java @@ -17,15 +17,23 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.Name; public final class ImportPath { private final @NotNull FqName fqName; + private final @Nullable Name alias; private final boolean isAllUnder; public ImportPath(@NotNull FqName fqName, boolean isAllUnder) { + this(fqName, isAllUnder, null); + } + + public ImportPath(@NotNull FqName fqName, boolean isAllUnder, @Nullable Name alias) { this.fqName = fqName; this.isAllUnder = isAllUnder; + this.alias = alias; } public ImportPath(@NotNull String pathStr) { @@ -37,6 +45,8 @@ public final class ImportPath { this.isAllUnder = false; this.fqName = new FqName(pathStr); } + + alias = null; } public String getPathStr() { @@ -45,7 +55,7 @@ public final class ImportPath { @Override public String toString() { - return getPathStr(); + return getPathStr() + (alias != null ? " as " + alias.getName() : ""); } @NotNull @@ -53,21 +63,47 @@ public final class ImportPath { return fqName; } + @Nullable + public Name getAlias() { + return alias; + } + + public boolean hasAlias() { + return alias != null; + } + public boolean isAllUnder() { return isAllUnder; } + @Nullable + public Name getImportedName() { + if (!isAllUnder()) { + return alias != null ? alias : fqName.shortName(); + } + + return null; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + ImportPath path = (ImportPath) o; + + if (isAllUnder != path.isAllUnder) return false; + if (alias != null ? !alias.equals(path.alias) : path.alias != null) return false; + if (!fqName.equals(path.fqName)) return false; + + return true; + } + @Override public int hashCode() { - return 31 * fqName.hashCode() + (isAllUnder ? 1 : 0); - } - - @Override - public boolean equals(Object obj) { - if (this == obj) return true; - if (!(obj instanceof ImportPath)) return false; - - ImportPath other = (ImportPath) obj; - return fqName.equals(other.fqName) && (isAllUnder == other.isAllUnder); + int result = fqName.hashCode(); + result = 31 * result + (alias != null ? alias.hashCode() : 0); + result = 31 * result + (isAllUnder ? 1 : 0); + return result; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java b/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java index e22bb6f4517..648f8e790d5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java @@ -124,6 +124,10 @@ public final class QualifiedNamesUtil { } public static boolean isImported(@NotNull ImportPath alreadyImported, @NotNull FqName fqName) { + if (alreadyImported.hasAlias()) { + return false; + } + if (alreadyImported.isAllUnder() && !fqName.isRoot()) { return alreadyImported.fqnPart().equals(fqName.parent()); } @@ -132,7 +136,7 @@ public final class QualifiedNamesUtil { } public static boolean isImported(@NotNull ImportPath alreadyImported, @NotNull ImportPath newImport) { - if (newImport.isAllUnder()) { + if (newImport.isAllUnder() || newImport.hasAlias()) { return alreadyImported.equals(newImport); } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/weigher/JetExplicitlyImportedWeigher.java b/idea/src/org/jetbrains/jet/plugin/completion/weigher/JetExplicitlyImportedWeigher.java index 9bb244570c3..507e3007497 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/weigher/JetExplicitlyImportedWeigher.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/weigher/JetExplicitlyImportedWeigher.java @@ -57,7 +57,7 @@ public class JetExplicitlyImportedWeigher extends LookupElementWeigher { // Invalid name can be met for class object descriptor: Test.MyTest.A..testOther if (FqName.isValid(fqName.toString())) { ImportPath importPath = new ImportPath(fqName.toString()); - if (ImportInsertHelper.doNeedImport(importPath, null, file)) { + if (ImportInsertHelper.doNeedImport(importPath, file)) { return MyResult.notImported; } else { diff --git a/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java b/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java index 99ae2818802..2fc85dbec5e 100644 --- a/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java +++ b/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java @@ -101,8 +101,8 @@ public class JetImportOptimizer implements ImportOptimizer { continue; } - if (isUseful(importPath, anImport.getAliasName(), usedQualifiedNames)) { - ImportInsertHelper.addImportDirective(importPath, anImport.getAliasName(), jetFile); + if (isUseful(importPath, usedQualifiedNames)) { + ImportInsertHelper.addImportDirective(importPath, jetFile); } } } @@ -111,8 +111,8 @@ public class JetImportOptimizer implements ImportOptimizer { }; } - public static boolean isUseful(ImportPath importPath, @Nullable String aliasName, Collection usedNames) { - if (aliasName != null) { + public static boolean isUseful(ImportPath importPath, Collection usedNames) { + if (importPath.hasAlias()) { // TODO: Add better analysis for aliases return true; } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java index d8ac2e61c41..c8ea76c1fee 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassAndFunFix.java @@ -99,7 +99,7 @@ public class ImportClassAndFunFix extends JetHintAction @Override public boolean apply(@Nullable FqName fqName) { assert fqName != null; - return ImportInsertHelper.doNeedImport(new ImportPath(fqName, false), null, (JetFile) file); + return ImportInsertHelper.doNeedImport(new ImportPath(fqName, false), (JetFile) file); } }); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java index 1fd6ce27ad3..e9f2df7f592 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java @@ -74,7 +74,7 @@ public class ImportInsertHelper { * @param file File where directive should be added. */ public static void addImportDirective(@NotNull FqName importFqn, @NotNull JetFile file) { - addImportDirective(new ImportPath(importFqn, false), null, file); + addImportDirective(new ImportPath(importFqn, false), file); } public static void addImportDirectiveOrChangeToFqName(@NotNull FqName importFqn, @NotNull JetFile file, int refOffset, @NotNull PsiElement targetElement) { @@ -109,15 +109,15 @@ public class ImportInsertHelper { return; } } - addImportDirective(new ImportPath(importFqn, false), null, file); + addImportDirective(new ImportPath(importFqn, false), file); } - public static void addImportDirective(@NotNull ImportPath importPath, @Nullable String aliasName, @NotNull JetFile file) { - if (!doNeedImport(importPath, aliasName, file)) { + public static void addImportDirective(@NotNull ImportPath importPath, @NotNull JetFile file) { + if (!doNeedImport(importPath, file)) { return; } - JetImportDirective newDirective = JetPsiFactory.createImportDirective(file.getProject(), importPath, aliasName); + JetImportDirective newDirective = JetPsiFactory.createImportDirective(file.getProject(), importPath); List importDirectives = file.getImportDirectives(); if (!importDirectives.isEmpty()) { @@ -125,34 +125,36 @@ public class ImportInsertHelper { lastDirective.getParent().addAfter(newDirective, lastDirective); } else { - file.getNamespaceHeader().getParent().addAfter(newDirective, file.getNamespaceHeader()); + JetNamespaceHeader header = file.getNamespaceHeader(); + if (header == null) { + throw new IllegalStateException("Scripts are not supported: " + file.getName()); + } + + header.getParent().addAfter(newDirective, file.getNamespaceHeader()); } } /** * Check that import is useless. */ - private static boolean isImportedByDefault(@NotNull ImportPath importPath, @Nullable String aliasName, @NotNull FqName filePackageFqn) { + private static boolean isImportedByDefault(@NotNull ImportPath importPath, @NotNull FqName filePackageFqn) { if (importPath.fqnPart().isRoot()) { return true; } - if (aliasName != null) { - return false; - } + if (!importPath.isAllUnder() && !importPath.hasAlias()) { + // Single element import without .* and alias is useless + if (QualifiedNamesUtil.isOneSegmentFQN(importPath.fqnPart())) { + return true; + } - // Single element import without .* and alias is useless - if (!importPath.isAllUnder() && QualifiedNamesUtil.isOneSegmentFQN(importPath.fqnPart())) { - return true; - } - - // There's no need to import a declaration from the package of current file - if (!importPath.isAllUnder() && filePackageFqn.equals(importPath.fqnPart().parent())) { - return true; + // There's no need to import a declaration from the package of current file + if (filePackageFqn.equals(importPath.fqnPart().parent())) { + return true; + } } if (isImportedWithKotlinDefault(importPath)) return true; - if (isImportedWithJavaDefault(importPath)) return true; return false; @@ -176,13 +178,13 @@ public class ImportInsertHelper { return false; } - public static boolean doNeedImport(@NotNull ImportPath importPath, @Nullable String aliasName, @NotNull JetFile file) { - if (QualifiedNamesUtil.getFirstSegment(importPath.fqnPart().getFqName()).equals(JavaDescriptorResolver.JAVA_ROOT.getName())) { + public static boolean doNeedImport(@NotNull ImportPath importPath, @NotNull JetFile file) { + if (importPath.fqnPart().firstSegmentIs(JavaDescriptorResolver.JAVA_ROOT)) { FqName withoutJavaRoot = QualifiedNamesUtil.withoutFirstSegment(importPath.fqnPart()); - importPath = new ImportPath(withoutJavaRoot, importPath.isAllUnder()); + importPath = new ImportPath(withoutJavaRoot, importPath.isAllUnder(), importPath.getAlias()); } - if (isImportedByDefault(importPath, null, JetPsiUtil.getFQName(file))) { + if (isImportedByDefault(importPath, JetPsiUtil.getFQName(file))) { return false; } @@ -192,10 +194,8 @@ public class ImportInsertHelper { // Check if import is already present for (JetImportDirective directive : importDirectives) { ImportPath existentImportPath = JetPsiUtil.getImportPath(directive); - if (directive.getAliasName() == null && aliasName == null) { - if (existentImportPath != null && QualifiedNamesUtil.isImported(existentImportPath, importPath)) { - return false; - } + if (existentImportPath != null && QualifiedNamesUtil.isImported(existentImportPath, importPath)) { + return false; } } } From 6141d0305a2a62190a1186276acc1ccd6026eefb Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 17 Jan 2013 19:00:10 +0400 Subject: [PATCH 11/38] Test for ImportPath and JetImportDirective coherence --- .../jetbrains/jet/lang/psi/JetPsiUtil.java | 46 +++++++++++++++++-- .../jet/lang/psi/JetPsiUtilTest.java | 43 ++++++++++++++++- 2 files changed, 83 insertions(+), 6 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index 4a09f41652c..6dbf6d625f3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.types.expressions.OperatorConventions; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetToken; import org.jetbrains.jet.lexer.JetTokens; +import org.jetbrains.jet.util.QualifiedNamesUtil; import java.util.Collection; import java.util.HashSet; @@ -262,8 +263,8 @@ public class JetPsiUtil { return null; } - final JetExpression importedReference = importDirective.getImportedReference(); - if (importedReference == null) { + FqName importFqn = getFQName(importDirective.getImportedReference()); + if (importFqn == null) { return null; } @@ -273,7 +274,7 @@ public class JetPsiUtil { alias = Name.identifier(aliasName); } - return new ImportPath(new FqName(importedReference.getText().replaceAll(" ", "")), importDirective.isAllUnder(), alias); + return new ImportPath(importFqn, importDirective.isAllUnder(), alias); } @Nullable @@ -378,7 +379,8 @@ public class JetPsiUtil { } public static boolean isFirstPartInQualified(@NotNull JetSimpleNameExpression nameExpression) { - @SuppressWarnings("unchecked") JetUserType userType = PsiTreeUtil.getParentOfType(nameExpression, JetUserType.class, true, JetDeclaration.class); + @SuppressWarnings("unchecked") JetUserType userType = PsiTreeUtil.getParentOfType(nameExpression, JetUserType.class, true, + JetDeclaration.class); if (userType != null) { return PsiTreeUtil.isAncestor(userType.getFirstChild(), nameExpression, false); } @@ -490,4 +492,40 @@ public class JetPsiUtil { public static boolean isBackingFieldReference(@Nullable JetElement element) { return element instanceof JetSimpleNameExpression && isBackingFieldReference((JetSimpleNameExpression)element); } + + @Nullable + private static FqName getFQName(@Nullable JetExpression expression) { + if (expression == null) { + return null; + } + + if (expression instanceof JetDotQualifiedExpression) { + JetDotQualifiedExpression dotQualifiedExpression = (JetDotQualifiedExpression) expression; + FqName parentFqn = getFQName(dotQualifiedExpression.getReceiverExpression()); + Name child = getName(dotQualifiedExpression.getSelectorExpression()); + + return parentFqn != null && child != null ? parentFqn.child(child) : null; + } + else if (expression instanceof JetSimpleNameExpression) { + JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression; + return FqName.topLevel(simpleNameExpression.getReferencedNameAsName()); + } + else { + throw new IllegalArgumentException("Can't construct fqn for: " + expression.getClass().toString()); + } + } + + @Nullable + private static Name getName(@Nullable JetExpression expression) { + if (expression == null) { + return null; + } + + if (expression instanceof JetSimpleNameExpression) { + return ((JetSimpleNameExpression) expression).getReferencedNameAsName(); + } + else { + throw new IllegalArgumentException("Can't construct name for: " + expression.getClass().toString()); + } + } } diff --git a/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java b/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java index 4a47d210ed2..d1d52eaa002 100644 --- a/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java @@ -16,10 +16,16 @@ package org.jetbrains.jet.lang.psi; +import com.intellij.psi.util.PsiTreeUtil; import junit.framework.Assert; -import junit.framework.TestCase; +import org.jetbrains.jet.JetLiteFixture; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.config.CompilerConfiguration; +import org.jetbrains.jet.lang.resolve.ImportPath; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.Name; -public class JetPsiUtilTest extends TestCase { +public class JetPsiUtilTest extends JetLiteFixture { public void testUnquotedIdentifier() { Assert.assertEquals("", JetPsiUtil.unquoteIdentifier("")); @@ -37,4 +43,37 @@ public class JetPsiUtilTest extends TestCase { Assert.assertEquals("$a2", JetPsiUtil.unquoteIdentifierOrFieldReference("$`a2`")); } + public void testConvertToImportPath() { + Assert.assertEquals(null, getImportPathFromParsed("import ")); + Assert.assertEquals(null, getImportPathFromParsed("import some.")); + Assert.assertEquals(null, getImportPathFromParsed("import *")); + Assert.assertEquals(null, getImportPathFromParsed("import some.test.* as SomeTest")); + Assert.assertEquals(new ImportPath(new FqName("some"), false), getImportPathFromParsed("import some?.Test")); + + Assert.assertEquals(new ImportPath(new FqName("some"), false), getImportPathFromParsed("import some")); + Assert.assertEquals(new ImportPath(new FqName("some"), true), getImportPathFromParsed("import some.*")); + Assert.assertEquals(new ImportPath(new FqName("some.Test"), false), getImportPathFromParsed("import some.Test")); + Assert.assertEquals(new ImportPath(new FqName("some.test"), true), getImportPathFromParsed("import some.test.*")); + Assert.assertEquals(new ImportPath(new FqName("some.test"), false, Name.identifier("SomeTest")), getImportPathFromParsed("import some.test as SomeTest")); + + Assert.assertEquals(new ImportPath(new FqName("some.Test"), false), getImportPathFromParsed("import some.\nTest")); + Assert.assertEquals(new ImportPath(new FqName("some.Test"), false), getImportPathFromParsed("import some./* hello world */Test")); + Assert.assertEquals(new ImportPath(new FqName("some.Test"), false), getImportPathFromParsed("import some. Test")); + + Assert.assertNotSame(new ImportPath(new FqName("some.test"), false), getImportPathFromParsed("import some.Test")); + } + + @Override + protected JetCoreEnvironment createEnvironment() { + return new JetCoreEnvironment(getTestRootDisposable(), new CompilerConfiguration()); + } + + private ImportPath getImportPathFromParsed(String text) { + JetImportDirective importDirective = + PsiTreeUtil.findChildOfType(JetPsiFactory.createFile(getProject(), text), JetImportDirective.class); + + assertNotNull("At least one import directive is expected", importDirective); + + return JetPsiUtil.getImportPath(importDirective); + } } From 73785e74bcd085a60ca02ab79c8fb08e47e7ee03 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 27 Dec 2012 17:52:47 +0400 Subject: [PATCH 12/38] Debug names for chained scopes in lazy resolve --- .../lang/resolve/lazy/LazyClassDescriptor.java | 15 ++++++++++++--- .../lang/resolve/lazy/LazyPackageDescriptor.java | 2 +- .../jet/lang/resolve/scopes/ChainedScope.java | 14 +++++++++++++- 3 files changed, 26 insertions(+), 5 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java index 32f4bb0e931..1ba80c895f1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java @@ -135,7 +135,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc scope.changeLockLevel(WritableScope.LockLevel.READING); PsiElement scopeAnchor = declarationProvider.getOwnerInfo().getScopeAnchor(); - scopeForClassHeaderResolution = new ChainedScope(this, scope, getScopeProvider().getResolutionScopeForDeclaration(scopeAnchor)); + scopeForClassHeaderResolution = new ChainedScope( + this, + "ScopeForClassHeaderResolution: " + getName(), + scope, getScopeProvider().getResolutionScopeForDeclaration(scopeAnchor)); } return scopeForClassHeaderResolution; } @@ -147,7 +150,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc scope.addLabeledDeclaration(this); scope.changeLockLevel(WritableScope.LockLevel.READING); - scopeForMemberDeclarationResolution = new ChainedScope(this, scope, getScopeForMemberLookup(), getScopeForClassHeaderResolution()); + scopeForMemberDeclarationResolution = new ChainedScope( + this, + "ScopeForMemberDeclarationResolution: " + getName(), + scope, getScopeForMemberLookup(), getScopeForClassHeaderResolution()); } return scopeForMemberDeclarationResolution; } @@ -167,7 +173,10 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc scope.changeLockLevel(WritableScope.LockLevel.READING); - scopeForPropertyInitializerResolution = new ChainedScope(this, scope, getScopeForMemberDeclarationResolution()); + scopeForPropertyInitializerResolution = new ChainedScope( + this, + "ScopeForPropertyInitializerResolution: " + getName(), + scope, getScopeForMemberDeclarationResolution()); } return scopeForPropertyInitializerResolution; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageDescriptor.java index b83184086a0..6dbfc039ab9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageDescriptor.java @@ -46,7 +46,7 @@ public class LazyPackageDescriptor extends AbstractNamespaceDescriptorImpl imple this.lazyScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this); - this.memberScope = new ChainedScope(this, lazyScope, scope); + this.memberScope = new ChainedScope(this, "Lazy package members scope: " + name, lazyScope, scope); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java index f0615d2dcb5..5a0b8322bf7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java @@ -30,13 +30,20 @@ import java.util.Set; public class ChainedScope implements JetScope { private final DeclarationDescriptor containingDeclaration; + private final String debugName; private final JetScope[] scopeChain; private Collection allDescriptors; private List implicitReceiverHierarchy; public ChainedScope(DeclarationDescriptor containingDeclaration, JetScope... scopes) { + this(containingDeclaration, "Untitled chained scope", scopes); + } + + public ChainedScope(DeclarationDescriptor containingDeclaration, String debugName, JetScope... scopes) { this.containingDeclaration = containingDeclaration; scopeChain = scopes.clone(); + + this.debugName = debugName; } @Override @@ -133,7 +140,7 @@ public class ChainedScope implements JetScope { @NotNull @Override - public Collection getDeclarationsByLabel(LabelName labelName) { + public Collection getDeclarationsByLabel(@NotNull LabelName labelName) { for (JetScope jetScope : scopeChain) { Collection declarationsByLabel = jetScope.getDeclarationsByLabel(labelName); if (!declarationsByLabel.isEmpty()) return declarationsByLabel; // TODO : merge? @@ -169,4 +176,9 @@ public class ChainedScope implements JetScope { public Collection getOwnDeclaredDescriptors() { throw new UnsupportedOperationException(); } + + @Override + public String toString() { + return debugName; + } } From 69f699e6a1acce8e6182beb654108a4a9fee3652 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Sat, 29 Dec 2012 16:46:19 +0400 Subject: [PATCH 13/38] Create enumeration LookupMode instead of using boolean onlyClasses --- .../jet/lang/resolve/ImportsResolver.java | 27 +++--- .../resolve/QualifiedExpressionResolver.java | 84 ++++++++++++------- .../resolve/lazy/ResolveSessionUtils.java | 6 +- .../jet/lang/resolve/lazy/ScopeProvider.java | 5 +- 4 files changed, 73 insertions(+), 49 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 84b4f3d03ce..ace34b45e2e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -36,6 +36,7 @@ import java.util.List; import java.util.Map; import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupMode; public class ImportsResolver { @NotNull @@ -75,30 +76,30 @@ public class ImportsResolver { } public void processTypeImports(@NotNull JetScope rootScope) { - processImports(true, rootScope); + processImports(LookupMode.ONLY_CLASSES, rootScope); } public void processMembersImports(@NotNull JetScope rootScope) { - processImports(false, rootScope); + processImports(LookupMode.EVERYTHING, rootScope); } - private void processImports(boolean onlyClasses, @NotNull JetScope rootScope) { + private void processImports(@NotNull LookupMode lookupMode, @NotNull JetScope rootScope) { for (JetFile file : context.getNamespaceDescriptors().keySet()) { WritableScope namespaceScope = context.getNamespaceScopes().get(file); - processImportsInFile(onlyClasses, namespaceScope, Lists.newArrayList(file.getImportDirectives()), rootScope); + processImportsInFile(lookupMode, namespaceScope, Lists.newArrayList(file.getImportDirectives()), rootScope); } for (JetScript script : context.getScripts().keySet()) { WritableScope scriptScope = context.getScriptScopes().get(script); - processImportsInFile(onlyClasses, scriptScope, script.getImportDirectives(), rootScope); + processImportsInFile(lookupMode, scriptScope, script.getImportDirectives(), rootScope); } } - private void processImportsInFile(boolean classes, WritableScope scope, List directives, JetScope rootScope) { - processImportsInFile(classes, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver, psiBuilder); + private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List directives, JetScope rootScope) { + processImportsInFile(lookupMode, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver, psiBuilder); } public static void processImportsInFile( - boolean onlyClasses, + @NotNull LookupMode lookupMode, @NotNull WritableScope namespaceScope, @NotNull List importDirectives, @NotNull JetScope rootScope, @@ -109,7 +110,7 @@ public class ImportsResolver { ) { Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope); - if (!onlyClasses) { + if (lookupMode == LookupMode.EVERYTHING) { namespaceScope.clearImports(); } @@ -119,7 +120,7 @@ public class ImportsResolver { JetImportDirective defaultImportDirective = psiBuilder.createImportDirective(defaultImportPath); qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, - temporaryTrace, configuration, onlyClasses); + temporaryTrace, configuration, lookupMode); } Map resolvedDirectives = Maps.newHashMap(); @@ -127,19 +128,19 @@ public class ImportsResolver { for (JetImportDirective importDirective : importDirectives) { Collection descriptors = qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter, - trace, configuration, onlyClasses); + trace, configuration, lookupMode); if (descriptors.size() == 1) { resolvedDirectives.put(importDirective, descriptors.iterator().next()); } for (DeclarationDescriptor descriptor : descriptors) { JetExpression importedReference = importDirective.getImportedReference(); - if (onlyClasses || importedReference == null) continue; + if (lookupMode == LookupMode.ONLY_CLASSES || importedReference == null) continue; reportPlatformClassMappedToKotlin(configuration, trace, importedReference, descriptor); } } delayedImporter.processImports(); - if (!onlyClasses) { + if (lookupMode == LookupMode.EVERYTHING) { for (JetImportDirective importDirective : importDirectives) { reportUselessImport(importDirective, namespaceScope, resolvedDirectives, trace); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index a36ba7b4d4e..a3ac86261b6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -36,6 +36,13 @@ import java.util.Set; import static org.jetbrains.jet.lang.diagnostics.Errors.*; public class QualifiedExpressionResolver { + public enum LookupMode { + // Only classifier and packages are resolved + ONLY_CLASSES, + + // Resolve all descriptors + EVERYTHING + } @NotNull public Collection analyseImportReference( @@ -44,7 +51,7 @@ public class QualifiedExpressionResolver { @NotNull BindingTrace trace, @NotNull ModuleConfiguration moduleConfiguration ) { - return processImportReference(importDirective, scope, scope, Importer.DO_NOTHING, trace, moduleConfiguration, false); + return processImportReference(importDirective, scope, scope, Importer.DO_NOTHING, trace, moduleConfiguration, LookupMode.EVERYTHING); } @NotNull @@ -55,7 +62,7 @@ public class QualifiedExpressionResolver { @NotNull Importer importer, @NotNull BindingTrace trace, @NotNull ModuleConfiguration moduleConfiguration, - boolean onlyClasses + @NotNull LookupMode lookupMode ) { if (importDirective.isAbsoluteInRootNamespace()) { trace.report(UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")); // TODO @@ -69,16 +76,20 @@ public class QualifiedExpressionResolver { Collection descriptors; if (importedReference instanceof JetQualifiedExpression) { //store result only when we find all descriptors, not only classes on the second phase - descriptors = lookupDescriptorsForQualifiedExpression((JetQualifiedExpression)importedReference, scope, scopeToCheckVisibility, trace, onlyClasses, !onlyClasses); + descriptors = lookupDescriptorsForQualifiedExpression( + (JetQualifiedExpression)importedReference, scope, scopeToCheckVisibility, trace, + lookupMode, lookupMode == LookupMode.EVERYTHING); } else { assert importedReference instanceof JetSimpleNameExpression; - descriptors = lookupDescriptorsForSimpleNameReference((JetSimpleNameExpression)importedReference, scope, scopeToCheckVisibility, trace, onlyClasses, true, !onlyClasses); + descriptors = lookupDescriptorsForSimpleNameReference( + (JetSimpleNameExpression)importedReference, scope, scopeToCheckVisibility, trace, + lookupMode, true, lookupMode == LookupMode.EVERYTHING); } JetSimpleNameExpression referenceExpression = JetPsiUtil.getLastReference(importedReference); if (importDirective.isAllUnder()) { - if (referenceExpression == null || !canImportMembersFrom(descriptors, referenceExpression, trace, onlyClasses)) { + if (referenceExpression == null || !canImportMembersFrom(descriptors, referenceExpression, trace, lookupMode)) { return Collections.emptyList(); } @@ -101,18 +112,20 @@ public class QualifiedExpressionResolver { } private boolean canImportMembersFrom(@NotNull Collection descriptors, - @NotNull JetSimpleNameExpression reference, @NotNull BindingTrace trace, boolean onlyClasses) { + @NotNull JetSimpleNameExpression reference, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode + ) { - if (onlyClasses) { + if (lookupMode == LookupMode.ONLY_CLASSES) { return true; } + if (descriptors.size() == 1) { - return canImportMembersFrom(descriptors.iterator().next(), reference, trace, onlyClasses); + return canImportMembersFrom(descriptors.iterator().next(), reference, trace, lookupMode); } TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace, "trace to find out if members can be imported from", reference); boolean canImport = false; for (DeclarationDescriptor descriptor : descriptors) { - canImport |= canImportMembersFrom(descriptor, reference, temporaryTrace, onlyClasses); + canImport |= canImportMembersFrom(descriptor, reference, temporaryTrace, lookupMode); } if (!canImport) { temporaryTrace.commit(); @@ -121,9 +134,10 @@ public class QualifiedExpressionResolver { } private boolean canImportMembersFrom(@NotNull DeclarationDescriptor descriptor, - @NotNull JetSimpleNameExpression reference, @NotNull BindingTrace trace, boolean onlyClasses) { + @NotNull JetSimpleNameExpression reference, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode + ) { - assert !onlyClasses; + assert lookupMode == LookupMode.EVERYTHING; if (descriptor instanceof NamespaceDescriptor) { return true; } @@ -148,24 +162,26 @@ public class QualifiedExpressionResolver { } JetUserType qualifier = userType.getQualifier(); if (qualifier == null) { - return lookupDescriptorsForSimpleNameReference(referenceExpression, outerScope, outerScope, trace, true, false, true); + return lookupDescriptorsForSimpleNameReference(referenceExpression, outerScope, outerScope, trace, LookupMode.ONLY_CLASSES, false, true); } Collection declarationDescriptors = lookupDescriptorsForUserType(qualifier, outerScope, trace); - return lookupSelectorDescriptors(referenceExpression, declarationDescriptors, trace, outerScope, true, true); + return lookupSelectorDescriptors(referenceExpression, declarationDescriptors, trace, outerScope, LookupMode.ONLY_CLASSES, true); } @NotNull public Collection lookupDescriptorsForQualifiedExpression(@NotNull JetQualifiedExpression importedReference, - @NotNull JetScope outerScope, @NotNull JetScope scopeToCheckVisibility, @NotNull BindingTrace trace, boolean onlyClasses, boolean storeResult) { + @NotNull JetScope outerScope, @NotNull JetScope scopeToCheckVisibility, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode, boolean storeResult) { JetExpression receiverExpression = importedReference.getReceiverExpression(); Collection declarationDescriptors; if (receiverExpression instanceof JetQualifiedExpression) { - declarationDescriptors = lookupDescriptorsForQualifiedExpression((JetQualifiedExpression)receiverExpression, outerScope, scopeToCheckVisibility, trace, onlyClasses, storeResult); + declarationDescriptors = lookupDescriptorsForQualifiedExpression((JetQualifiedExpression)receiverExpression, outerScope, scopeToCheckVisibility, trace, + lookupMode, storeResult); } else { assert receiverExpression instanceof JetSimpleNameExpression; - declarationDescriptors = lookupDescriptorsForSimpleNameReference((JetSimpleNameExpression)receiverExpression, outerScope, scopeToCheckVisibility, trace, onlyClasses, true, storeResult); + declarationDescriptors = lookupDescriptorsForSimpleNameReference((JetSimpleNameExpression)receiverExpression, outerScope, scopeToCheckVisibility, trace, + lookupMode, true, storeResult); } JetExpression selectorExpression = importedReference.getSelectorExpression(); @@ -175,37 +191,40 @@ public class QualifiedExpressionResolver { JetSimpleNameExpression selector = (JetSimpleNameExpression)selectorExpression; JetSimpleNameExpression lastReference = JetPsiUtil.getLastReference(receiverExpression); - if (lastReference == null || !canImportMembersFrom(declarationDescriptors, lastReference, trace, onlyClasses)) { + if (lastReference == null || !canImportMembersFrom(declarationDescriptors, lastReference, trace, lookupMode)) { return Collections.emptyList(); } - return lookupSelectorDescriptors(selector, declarationDescriptors, trace, scopeToCheckVisibility, onlyClasses, storeResult); + return lookupSelectorDescriptors(selector, declarationDescriptors, trace, scopeToCheckVisibility, lookupMode, storeResult); } @NotNull private Collection lookupSelectorDescriptors(@NotNull JetSimpleNameExpression selector, @NotNull Collection declarationDescriptors, @NotNull BindingTrace trace, - @NotNull JetScope scopeToCheckVisibility, boolean onlyClasses, boolean storeResult) { + @NotNull JetScope scopeToCheckVisibility, @NotNull LookupMode lookupMode, boolean storeResult) { Set results = Sets.newHashSet(); for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) { if (declarationDescriptor instanceof NamespaceDescriptor) { - addResult(results, lookupSimpleNameReference(selector, ((NamespaceDescriptor)declarationDescriptor).getMemberScope(), onlyClasses, true)); + addResult(results, lookupSimpleNameReference(selector, ((NamespaceDescriptor)declarationDescriptor).getMemberScope(), + lookupMode, true)); } if (declarationDescriptor instanceof ClassDescriptor) { - addResult(results, lookupSimpleNameReference(selector, getAppropriateScope((ClassDescriptor)declarationDescriptor, onlyClasses), onlyClasses, false)); + addResult(results, lookupSimpleNameReference(selector, getAppropriateScope((ClassDescriptor)declarationDescriptor, + lookupMode), lookupMode, false)); ClassDescriptor classObjectDescriptor = ((ClassDescriptor)declarationDescriptor).getClassObjectDescriptor(); if (classObjectDescriptor != null) { - addResult(results, lookupSimpleNameReference(selector, getAppropriateScope(classObjectDescriptor, onlyClasses), onlyClasses, false)); + addResult(results, lookupSimpleNameReference(selector, getAppropriateScope(classObjectDescriptor, lookupMode), + lookupMode, false)); } } } - return filterAndStoreResolutionResult(results, selector, trace, scopeToCheckVisibility, onlyClasses, storeResult); + return filterAndStoreResolutionResult(results, selector, trace, scopeToCheckVisibility, lookupMode, storeResult); } @NotNull - private JetScope getAppropriateScope(@NotNull ClassDescriptor classDescriptor, boolean onlyClasses) { - return onlyClasses ? classDescriptor.getUnsubstitutedInnerClassesScope() : classDescriptor.getDefaultType().getMemberScope(); + private JetScope getAppropriateScope(@NotNull ClassDescriptor classDescriptor, @NotNull LookupMode lookupMode) { + return lookupMode == LookupMode.ONLY_CLASSES ? classDescriptor.getUnsubstitutedInnerClassesScope() : classDescriptor.getDefaultType().getMemberScope(); } private void addResult(@NotNull Set results, @NotNull LookupResult result) { @@ -216,17 +235,18 @@ public class QualifiedExpressionResolver { @NotNull public Collection lookupDescriptorsForSimpleNameReference(@NotNull JetSimpleNameExpression referenceExpression, - @NotNull JetScope outerScope, @NotNull JetScope scopeToCheckVisibility, @NotNull BindingTrace trace, boolean onlyClasses, boolean namespaceLevel, boolean storeResult) { + @NotNull JetScope outerScope, @NotNull JetScope scopeToCheckVisibility, @NotNull BindingTrace trace, @NotNull LookupMode lookupMode, boolean namespaceLevel, boolean storeResult) { - LookupResult lookupResult = lookupSimpleNameReference(referenceExpression, outerScope, onlyClasses, namespaceLevel); + LookupResult lookupResult = lookupSimpleNameReference(referenceExpression, outerScope, lookupMode, namespaceLevel); if (lookupResult == LookupResult.EMPTY) return Collections.emptyList(); return filterAndStoreResolutionResult(Collections.singletonList((SuccessfulLookupResult)lookupResult), referenceExpression, trace, scopeToCheckVisibility, - onlyClasses, storeResult); + lookupMode, storeResult); } @NotNull private LookupResult lookupSimpleNameReference(@NotNull JetSimpleNameExpression referenceExpression, - @NotNull JetScope outerScope, boolean onlyClasses, boolean namespaceLevel) { + @NotNull JetScope outerScope, @NotNull LookupMode lookupMode, boolean namespaceLevel) { + Name referencedName = referenceExpression.getReferencedNameAsName(); Set descriptors = Sets.newHashSet(); @@ -240,7 +260,7 @@ public class QualifiedExpressionResolver { descriptors.add(classifierDescriptor); } - if (onlyClasses) { + if (lookupMode == LookupMode.ONLY_CLASSES) { ClassDescriptor objectDescriptor = outerScope.getObjectDescriptor(referencedName); if (objectDescriptor != null) { descriptors.add(objectDescriptor); @@ -261,7 +281,7 @@ public class QualifiedExpressionResolver { @NotNull private Collection filterAndStoreResolutionResult(@NotNull Collection lookupResults, @NotNull JetSimpleNameExpression referenceExpression, @NotNull final BindingTrace trace, @NotNull JetScope scopeToCheckVisibility, - boolean onlyClasses, boolean storeResult) { + @NotNull LookupMode lookupMode, boolean storeResult) { if (lookupResults.isEmpty()) { return Collections.emptyList(); @@ -284,7 +304,7 @@ public class QualifiedExpressionResolver { } Collection filteredDescriptors; - if (onlyClasses) { + if (lookupMode == LookupMode.ONLY_CLASSES) { filteredDescriptors = Collections2.filter(descriptors, new Predicate() { @Override public boolean apply(@Nullable DeclarationDescriptor descriptor) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java index dae859ea127..0d65c30842d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java @@ -38,6 +38,8 @@ import org.jetbrains.jet.util.QualifiedNamesUtil; import java.util.*; +import static org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupMode; + public class ResolveSessionUtils { // This name is used as a key for the case when something has no name _due to a syntactic error_ @@ -285,11 +287,11 @@ public class ResolveSessionUtils { if (element instanceof JetDotQualifiedExpression) { descriptors = qualifiedExpressionResolver.lookupDescriptorsForQualifiedExpression( - (JetDotQualifiedExpression) element, rootPackage.getMemberScope(), scope, trace, false, false); + (JetDotQualifiedExpression) element, rootPackage.getMemberScope(), scope, trace, LookupMode.EVERYTHING, false); } else { descriptors = qualifiedExpressionResolver.lookupDescriptorsForSimpleNameReference( - (JetSimpleNameExpression) element, rootPackage.getMemberScope(), scope, trace, false, false, false); + (JetSimpleNameExpression) element, rootPackage.getMemberScope(), scope, trace, LookupMode.EVERYTHING, false, false); } for (DeclarationDescriptor descriptor : descriptors) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index 8e5160902e5..0b0a36ef6aa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java @@ -23,6 +23,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.scopes.*; @@ -78,7 +79,7 @@ public class ScopeProvider { fileScope.importScope(rootPackageDescriptor.getMemberScope()); } - ImportsResolver.processImportsInFile(true, fileScope, Lists.newArrayList(file.getImportDirectives()), + ImportsResolver.processImportsInFile(QualifiedExpressionResolver.LookupMode.ONLY_CLASSES, fileScope, Lists.newArrayList(file.getImportDirectives()), rootPackageDescriptor.getMemberScope(), resolveSession.getModuleConfiguration(), resolveSession.getTrace(), resolveSession.getInjector().getQualifiedExpressionResolver(), @@ -119,7 +120,7 @@ public class ScopeProvider { fileMemberScope.changeLockLevel(WritableScope.LockLevel.BOTH); - ImportsResolver.processImportsInFile(false, fileMemberScope, Lists.newArrayList(file.getImportDirectives()), + ImportsResolver.processImportsInFile(QualifiedExpressionResolver.LookupMode.EVERYTHING, fileMemberScope, Lists.newArrayList(file.getImportDirectives()), rootPackageDescriptor.getMemberScope(), resolveSession.getModuleConfiguration(), resolveSession.getTrace(), resolveSession.getInjector().getQualifiedExpressionResolver(), From f2e78d9064585dce7aa7c003aa23d214913c2c59 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 25 Dec 2012 21:34:02 +0400 Subject: [PATCH 14/38] Create scope with lazy import resolve --- .../jetbrains/jet/lang/psi/JetPsiBuilder.java | 17 ++ .../jetbrains/jet/lang/resolve/Importer.java | 3 +- .../lang/resolve/lazy/ImportsProvider.java | 95 +++++++ .../lang/resolve/lazy/LazyImportScope.java | 268 ++++++++++++++++++ .../resolve/lazy/LazyPackageMemberScope.java | 3 +- .../resolve/lazy/ResolveSessionUtils.java | 10 +- .../jet/lang/resolve/lazy/ScopeProvider.java | 127 ++++----- .../resolve/scopes/JetScopeSelectorUtil.java | 131 +++++++++ .../diagnostics/tests/scopes/kt1080.kt | 6 +- .../lazyResolve/diagnostics/scopes/kt1080.txt | 6 + ...ctionWithAllUnderImportAfterNamedImport.kt | 22 ++ ...tionWithAllUnderImportAfterNamedImport.txt | 3 + ...esolveNamespaceComparingTestGenerated.java | 5 + 13 files changed, 616 insertions(+), 80 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java create mode 100644 compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.kt create mode 100644 compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.txt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java index 3b189edc4c0..5f09d3a7829 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java @@ -16,12 +16,16 @@ package org.jetbrains.jet.lang.psi; +import com.google.common.base.Function; +import com.google.common.collect.Collections2; import com.google.common.collect.Maps; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.ImportPath; import javax.inject.Inject; +import java.util.Collection; import java.util.Map; public class JetPsiBuilder { @@ -36,6 +40,7 @@ public class JetPsiBuilder { this.project = project; } + @NotNull public JetImportDirective createImportDirective(@NotNull ImportPath importPath) { JetImportDirective directive = importsCache.get(importPath); if (directive != null) { @@ -47,4 +52,16 @@ public class JetPsiBuilder { return createdDirective; } + + @NotNull + public Collection createImportDirectives(@NotNull Collection importPaths) { + return Collections2.transform(importPaths, + new Function() { + @Override + public JetImportDirective apply(@Nullable ImportPath path) { + assert path != null; + return createImportDirective(path); + } + }); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java index e04683baee2..02519abe607 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java @@ -31,8 +31,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import java.util.Collection; import java.util.List; -/*package*/ interface Importer { - +public interface Importer { void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap); void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java new file mode 100644 index 00000000000..bb122c6ab15 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java @@ -0,0 +1,95 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.lazy; + +import com.google.common.collect.*; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.JetImportDirective; +import org.jetbrains.jet.lang.psi.JetPsiUtil; +import org.jetbrains.jet.lang.resolve.ImportPath; +import org.jetbrains.jet.lang.resolve.name.Name; + +import java.util.*; + +class ImportsProvider { + private final List importDirectives; + + private ListMultimap nameToDirectives = null; + private List allUnderImports = null; + private boolean indexed; + + public ImportsProvider(List importDirectives) { + this.importDirectives = importDirectives; + } + + @NotNull + public List getImports(@NotNull Name name) { + createIndex(); + return nameToDirectives.containsKey(name) ? nameToDirectives.get(name) : allUnderImports; + } + + @NotNull + public List getAllImports() { + return importDirectives; + } + + private void createIndex() { + if (indexed) { + return; + } + + ImmutableListMultimap.Builder namesToRelativeImportsBuilder = ImmutableListMultimap.builder(); + + Set processedAliases = Sets.newHashSet(); + List processedAllUnderImports = Lists.newArrayList(); + + for (JetImportDirective anImport : importDirectives) { + ImportPath path = JetPsiUtil.getImportPath(anImport); + if (path == null) { + // Could be some parse errors + continue; + } + + if (path.isAllUnder()) { + processedAllUnderImports.add(anImport); + + // All-Under import is relevant to all names found so far + for (Name aliasName : processedAliases) { + namesToRelativeImportsBuilder.put(aliasName, anImport); + } + } + else { + Name aliasName = path.getImportedName(); + assert aliasName != null; + + if (!processedAliases.contains(aliasName)) { + processedAliases.add(aliasName); + + // Add to relevant imports all all-under imports found by this moment + namesToRelativeImportsBuilder.putAll(aliasName, processedAllUnderImports); + } + + namesToRelativeImportsBuilder.put(aliasName, anImport); + } + } + + allUnderImports = ImmutableList.copyOf(processedAllUnderImports); + nameToDirectives = namesToRelativeImportsBuilder.build(); + + indexed = true; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java new file mode 100644 index 00000000000..3f00a4a9415 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java @@ -0,0 +1,268 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.lazy; + +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetImportDirective; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.Importer; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.LabelName; +import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.resolve.scopes.*; + +import java.util.*; + +import static org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupMode; + +public class LazyImportScope implements JetScope { + private static class ImportResolveStatus { + private final LookupMode lookupMode; + private final JetScope scope; + + ImportResolveStatus(LookupMode lookupMode, JetScope scope) { + this.lookupMode = lookupMode; + this.scope = scope; + } + } + + private final ResolveSession resolveSession; + private final NamespaceDescriptor packageDescriptor; + private final ImportsProvider importsProvider; + private final JetScope rootScope; + private final BindingTrace traceForImportResolve; + private final String debugName; + + private final Map importedScopes = Maps.newHashMap(); + private JetImportDirective directiveUnderResolve = null; + + public LazyImportScope( + @NotNull ResolveSession resolveSession, + @NotNull NamespaceDescriptor packageDescriptor, + @NotNull List imports, + @NotNull BindingTrace traceForImportResolve, + @NotNull String debugName + ) { + this.resolveSession = resolveSession; + this.packageDescriptor = packageDescriptor; + this.importsProvider = new ImportsProvider(imports); + this.traceForImportResolve = traceForImportResolve; + this.debugName = debugName; + + NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); + if (rootPackageDescriptor == null) { + throw new IllegalStateException("Root package not found"); + } + rootScope = rootPackageDescriptor.getMemberScope(); + } + + public static LazyImportScope createImportScopeForFile( + @NotNull ResolveSession resolveSession, + @NotNull NamespaceDescriptor packageDescriptor, + @NotNull JetFile jetFile, + @NotNull BindingTrace traceForImportResolve, + @NotNull String debugName + ) { + return new LazyImportScope( + resolveSession, + packageDescriptor, + Lists.reverse(jetFile.getImportDirectives()), + traceForImportResolve, + debugName); + } + + @Nullable + private D selectFirstFromImports( + Name name, + LookupMode lookupMode, + JetScopeSelectorUtil.ScopeByNameSelector descriptorSelector + ) { + for (JetImportDirective directive : importsProvider.getImports(name)) { + if (directive == directiveUnderResolve) { + // This is the recursion in imports analysis + return null; + } + + D foundDescriptor = descriptorSelector.get(getImportScope(directive, lookupMode), name); + if (foundDescriptor != null) { + return foundDescriptor; + } + } + + return null; + } + + @NotNull + private Collection collectFromImports( + Name name, + LookupMode lookupMode, + JetScopeSelectorUtil.ScopeByNameMultiSelector descriptorsSelector + ) { + Set descriptors = Sets.newHashSet(); + for (JetImportDirective directive : importsProvider.getImports(name)) { + if (directive == directiveUnderResolve) { + // This is the recursion in imports analysis + throw new IllegalStateException("Recursion while resolving many imports: " + directive.getText()); + } + + descriptors.addAll(descriptorsSelector.get(getImportScope(directive, lookupMode), name)); + } + + return descriptors; + } + + @NotNull + private Collection collectFromImports( + LookupMode lookupMode, + JetScopeSelectorUtil.ScopeDescriptorSelector descriptorsSelector + ) { + Set descriptors = Sets.newHashSet(); + for (JetImportDirective directive : importsProvider.getAllImports()) { + if (directive == directiveUnderResolve) { + // This is the recursion in imports analysis + throw new IllegalStateException("Recursion while resolving many imports: " + directive.getText()); + } + + descriptors.addAll(descriptorsSelector.get(getImportScope(directive, lookupMode))); + } + + return descriptors; + } + + @NotNull + private JetScope getImportScope(JetImportDirective directive, LookupMode lookupMode) { + ImportResolveStatus status = importedScopes.get(directive); + if (status != null && (lookupMode == status.lookupMode || status.lookupMode == LookupMode.EVERYTHING)) { + return status.scope; + } + + WritableScope directiveImportScope = new WritableScopeImpl( + JetScope.EMPTY, packageDescriptor, RedeclarationHandler.DO_NOTHING, + "Scope for import '" + directive.getText() + "' resolve in " + toString()); + directiveImportScope.changeLockLevel(WritableScope.LockLevel.BOTH); + + Importer.StandardImporter importer = new Importer.StandardImporter(directiveImportScope); + directiveUnderResolve = directive; + + try { + resolveSession.getInjector().getQualifiedExpressionResolver().processImportReference( + directive, + rootScope, + packageDescriptor.getMemberScope(), + importer, + traceForImportResolve, + resolveSession.getModuleConfiguration(), + lookupMode); + } + finally { + directiveUnderResolve = null; + directiveImportScope.changeLockLevel(WritableScope.LockLevel.READING); + importedScopes.put(directive, new ImportResolveStatus(lookupMode, directiveImportScope)); + } + + return directiveImportScope; + } + + @Nullable + @Override + public ClassifierDescriptor getClassifier(@NotNull Name name) { + return selectFirstFromImports(name, LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.CLASSIFIER_DESCRIPTOR_SCOPE_SELECTOR); + } + + @Nullable + @Override + public ClassDescriptor getObjectDescriptor(@NotNull Name name) { + return selectFirstFromImports(name, LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.NAMED_OBJECT_SCOPE_SELECTOR); + } + + @NotNull + @Override + public Collection getObjectDescriptors() { + return collectFromImports(LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.OBJECTS_SCOPE_SELECTOR); + } + + @Nullable + @Override + public NamespaceDescriptor getNamespace(@NotNull Name name) { + return selectFirstFromImports(name, LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.NAMESPACE_SCOPE_SELECTOR); + } + + @NotNull + @Override + public Collection getProperties(@NotNull Name name) { + return collectFromImports(name, LookupMode.EVERYTHING, JetScopeSelectorUtil.NAMED_PROPERTIES_SCOPE_SELECTOR); + } + + @Nullable + @Override + public VariableDescriptor getLocalVariable(@NotNull Name name) { + return null; + } + + @NotNull + @Override + public Collection getFunctions(@NotNull Name name) { + return collectFromImports(name, LookupMode.EVERYTHING, JetScopeSelectorUtil.NAMED_FUNCTION_SCOPE_SELECTOR); + } + + @NotNull + @Override + public DeclarationDescriptor getContainingDeclaration() { + return packageDescriptor; + } + + @NotNull + @Override + public Collection getDeclarationsByLabel(@NotNull LabelName labelName) { + return Collections.emptyList(); + } + + @Nullable + @Override + public PropertyDescriptor getPropertyByFieldReference(@NotNull Name fieldName) { + return null; + } + + @NotNull + @Override + public Collection getAllDescriptors() { + return collectFromImports(LookupMode.EVERYTHING, JetScopeSelectorUtil.ALL_DESCRIPTORS_SCOPE_SELECTOR); + } + + @NotNull + @Override + public List getImplicitReceiversHierarchy() { + return Collections.emptyList(); + } + + @NotNull + @Override + public Collection getOwnDeclaredDescriptors() { + return Collections.emptyList(); + } + + @Override + public String toString() { + return "LazyImportScope: " + debugName; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java index 3507cd94c4e..4edbbb5067f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java @@ -68,8 +68,7 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope fileScopes = new WeakHashMap(); + + private final NotNullLazyValue defaultImportsScope = new NotNullLazyValue() { + @NotNull + @Override + protected JetScope compute() { + return createScopeWithDefaultImports(); + } + }; + public ScopeProvider(@NotNull ResolveSession resolveSession) { this.resolveSession = resolveSession; } - private final Map fileScopeWithImportedClassesCache = new WeakHashMap(); - private final Map fileScopeWithAllImportedCache = new WeakHashMap(); - @NotNull - public JetScope getFileScopeWithImportedClasses(JetFile file) { - JetScope scope = fileScopeWithImportedClassesCache.get(file); + public JetScope getFileScope(JetFile file) { + JetScope scope = fileScopes.get(file); if (scope == null) { - scope = createFileScopeWithImportedClasses(file); - fileScopeWithImportedClassesCache.put(file, scope); + scope = createFileScope(file); + fileScopes.put(file, scope); } return scope; } - @NotNull - public JetScope getFileScopeWithAllImported(JetFile file) { - JetScope scope = fileScopeWithAllImportedCache.get(file); - if (scope == null) { - scope = createFileScopeWithAllImported(file); - fileScopeWithAllImportedCache.put(file, scope); - } - return scope; - } - - private JetScope createFileScopeWithImportedClasses(JetFile file) { - NamespaceDescriptor packageDescriptor = getFilePackageDescriptor(file); - - WritableScope fileScope = new WritableScopeImpl( - JetScope.EMPTY, packageDescriptor, RedeclarationHandler.DO_NOTHING, "File scope for declaration resolution with only classes imported"); - - fileScope.changeLockLevel(WritableScope.LockLevel.BOTH); - + private JetScope createFileScope(JetFile file) { NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); if (rootPackageDescriptor == null) { throw new IllegalStateException("Root package not found"); } - // Don't import twice - if (!packageDescriptor.getQualifiedName().equals(FqName.ROOT)) { - fileScope.importScope(rootPackageDescriptor.getMemberScope()); - } + NamespaceDescriptor packageDescriptor = getFilePackageDescriptor(file); - ImportsResolver.processImportsInFile(QualifiedExpressionResolver.LookupMode.ONLY_CLASSES, fileScope, Lists.newArrayList(file.getImportDirectives()), - rootPackageDescriptor.getMemberScope(), - resolveSession.getModuleConfiguration(), resolveSession.getTrace(), - resolveSession.getInjector().getQualifiedExpressionResolver(), - resolveSession.getInjector().getJetPsiBuilder()); + JetScope importsScope = LazyImportScope.createImportScopeForFile( + resolveSession, + packageDescriptor, + file, + resolveSession.getTrace(), + "Lazy Imports Scope for file " + file.getName()); - fileScope.changeLockLevel(WritableScope.LockLevel.READING); - - return new ChainedScope(packageDescriptor, packageDescriptor.getMemberScope(), fileScope); + return new ChainedScope(packageDescriptor, + "File scope: " + file.getName(), + rootPackageDescriptor.getMemberScope(), + packageDescriptor.getMemberScope(), + importsScope, + defaultImportsScope.getValue()); } + private JetScope createScopeWithDefaultImports() { + NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); + if (rootPackageDescriptor == null) { + throw new IllegalStateException("Root package not found"); + } + + JetPsiBuilder jetPsiBuilder = resolveSession.getInjector().getJetPsiBuilder(); + List defaultImports = resolveSession.getModuleConfiguration().getDefaultImports(); + + Collection defaultImportDirectives = jetPsiBuilder.createImportDirectives(defaultImports); + + return new LazyImportScope( + resolveSession, + rootPackageDescriptor, + Lists.reverse(Lists.newArrayList(defaultImportDirectives)), + TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve"), + "Lazy default imports scope"); + } + + @NotNull private NamespaceDescriptor getFilePackageDescriptor(JetFile file) { - // package JetNamespaceHeader header = file.getNamespaceHeader(); if (header == null) { throw new IllegalArgumentException("Scripts are not supported: " + file.getName()); @@ -103,34 +114,10 @@ public class ScopeProvider { if (packageDescriptor == null) { throw new IllegalStateException("Package not found: " + fqName + " maybe the file is not in scope of this resolve session: " + file.getName()); } + return packageDescriptor; } - private JetScope createFileScopeWithAllImported(JetFile file) { - JetScope scopeWithImportedClasses = getFileScopeWithImportedClasses(file); - NamespaceDescriptor packageDescriptor = getFilePackageDescriptor(file); - - NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); - if (rootPackageDescriptor == null) { - throw new IllegalStateException("Root package not found"); - } - - WritableScope fileMemberScope = new WritableScopeImpl( - JetScope.EMPTY, packageDescriptor, RedeclarationHandler.DO_NOTHING, "File scope for members declaration resolution with non-class imports"); - - fileMemberScope.changeLockLevel(WritableScope.LockLevel.BOTH); - - ImportsResolver.processImportsInFile(QualifiedExpressionResolver.LookupMode.EVERYTHING, fileMemberScope, Lists.newArrayList(file.getImportDirectives()), - rootPackageDescriptor.getMemberScope(), - resolveSession.getModuleConfiguration(), resolveSession.getTrace(), - resolveSession.getInjector().getQualifiedExpressionResolver(), - resolveSession.getInjector().getJetPsiBuilder()); - - fileMemberScope.changeLockLevel(WritableScope.LockLevel.READING); - - return new ChainedScope(packageDescriptor, scopeWithImportedClasses, fileMemberScope); - } - @NotNull public JetScope getResolutionScopeForDeclaration(@NotNull PsiElement elementOfDeclaration) { JetDeclaration jetDeclaration = PsiTreeUtil.getParentOfType(elementOfDeclaration, JetDeclaration.class, false); @@ -140,7 +127,7 @@ public class ScopeProvider { JetDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(jetDeclaration, JetDeclaration.class); if (parentDeclaration == null) { - return getFileScopeWithAllImported((JetFile) elementOfDeclaration.getContainingFile()); + return getFileScope((JetFile) elementOfDeclaration.getContainingFile()); } assert jetDeclaration != null : "Can't happen because of getParentOfType(null, ?) == null"; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java new file mode 100644 index 00000000000..309034be3e0 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java @@ -0,0 +1,131 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.scopes; + +import com.google.common.collect.Sets; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.name.Name; + +import java.util.Collection; +import java.util.Set; + +public class JetScopeSelectorUtil { + private JetScopeSelectorUtil() { + } + + public interface ScopeByNameSelector { + @Nullable + D get(@NotNull JetScope scope, @NotNull Name name); + } + + public interface ScopeByNameMultiSelector { + @NotNull + Collection get(JetScope scope, Name name); + } + + public interface ScopeDescriptorSelector { + @NotNull + Collection get(JetScope scope); + } + + @NotNull + public static Collection collect(Collection scopes, ScopeByNameMultiSelector selector, Name name) { + Set descriptors = Sets.newHashSet(); + + for (JetScope scope : scopes) { + descriptors.addAll(selector.get(scope, name)); + } + + return descriptors; + } + + @NotNull + public static Collection collect(Collection scopes, ScopeDescriptorSelector selector) { + Set descriptors = Sets.newHashSet(); + + for (JetScope scope : scopes) { + descriptors.addAll(selector.get(scope)); + } + + return descriptors; + } + + public static final ScopeByNameSelector CLASSIFIER_DESCRIPTOR_SCOPE_SELECTOR = + new ScopeByNameSelector() { + @Nullable + @Override + public ClassifierDescriptor get(@NotNull JetScope scope, @NotNull Name name) { + return scope.getClassifier(name); + } + }; + + public static final ScopeByNameSelector NAMED_OBJECT_SCOPE_SELECTOR = + new ScopeByNameSelector() { + @Nullable + @Override + public ClassDescriptor get(@NotNull JetScope scope, @NotNull Name name) { + return scope.getObjectDescriptor(name); + } + }; + + public static final ScopeByNameSelector NAMESPACE_SCOPE_SELECTOR = + new ScopeByNameSelector() { + @Nullable + @Override + public NamespaceDescriptor get(@NotNull JetScope scope, @NotNull Name name) { + return scope.getNamespace(name); + } + }; + + public static final ScopeByNameMultiSelector NAMED_FUNCTION_SCOPE_SELECTOR = + new ScopeByNameMultiSelector() { + @NotNull + @Override + public Collection get(@NotNull JetScope scope, @NotNull Name name) { + return scope.getFunctions(name); + } + }; + + public static final ScopeByNameMultiSelector NAMED_PROPERTIES_SCOPE_SELECTOR = + new ScopeByNameMultiSelector() { + @NotNull + @Override + public Collection get(@NotNull JetScope scope, @NotNull Name name) { + return scope.getProperties(name); + } + }; + + public static final ScopeDescriptorSelector OBJECTS_SCOPE_SELECTOR = + new ScopeDescriptorSelector() { + @NotNull + @Override + public Collection get(@NotNull JetScope scope) { + return scope.getObjectDescriptors(); + } + }; + + public static final ScopeDescriptorSelector ALL_DESCRIPTORS_SCOPE_SELECTOR = + new ScopeDescriptorSelector() { + @NotNull + @Override + public Collection get(@NotNull JetScope scope) { + return scope.getAllDescriptors(); + } + }; +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt1080.kt b/compiler/testData/diagnostics/tests/scopes/kt1080.kt index 23d40f8fbe7..fde50739bc8 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1080.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1080.kt @@ -7,9 +7,13 @@ import reflect.Const import b.* import d +import d.Test import b.d +class Some: Test() //FILE:b.kt -package b.d \ No newline at end of file +package b.d + +public open class Test \ No newline at end of file diff --git a/compiler/testData/lazyResolve/diagnostics/scopes/kt1080.txt b/compiler/testData/lazyResolve/diagnostics/scopes/kt1080.txt index 72425dfddb2..1df452aff48 100644 --- a/compiler/testData/lazyResolve/diagnostics/scopes/kt1080.txt +++ b/compiler/testData/lazyResolve/diagnostics/scopes/kt1080.txt @@ -3,6 +3,9 @@ namespace // namespace kt1080 +internal final class kt1080.Some : jet.Any { + public final /*constructor*/ fun (): kt1080.Some +} // // namespace b @@ -10,5 +13,8 @@ namespace b // namespace d +public open class b.d.Test : jet.Any { + public final /*constructor*/ fun (): b.d.Test +} // // diff --git a/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.kt b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.kt new file mode 100644 index 00000000000..cf512690411 --- /dev/null +++ b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.kt @@ -0,0 +1,22 @@ +//FILE:mainFile.kt +//---------------------------------------------------------------------------------- +package test + +import testing.other.* +import testing.TestFun + +// Resolve should be ambiguous +val a = TestFun() + + +//FILE:testing.kt +//---------------------------------------------------------------------------------- +package testing + +class TestFun + +//FILE:testingOther.kt +//---------------------------------------------------------------------------------- +package testing.other + +fun TestFun() = 12 diff --git a/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.txt b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.txt new file mode 100644 index 00000000000..5ce403563e0 --- /dev/null +++ b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.txt @@ -0,0 +1,3 @@ +package test + +internal val a : [ERROR : Type for TestFun()] diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index a43ff7e5b9d..c62f7876825 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -1952,6 +1952,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/genericFunction.kt"); } + @TestMetadata("importFunctionWithAllUnderImportAfterNamedImport.kt") + public void testImportFunctionWithAllUnderImportAfterNamedImport() throws Exception { + doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.kt"); + } + @TestMetadata("InnerClassNameClash.kt") public void testInnerClassNameClash() throws Exception { doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/InnerClassNameClash.kt"); From ee227f01b962156119b77b3c8a1273dc04a239d9 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 28 Dec 2012 17:00:00 +0400 Subject: [PATCH 15/38] Add test for checking ambiguity for root package and the same package --- .../tests/scopes/AmbiguityBetweenRootAndPackage.kt | 12 ++++++++++++ .../overload/AmbiguityBetweenRootAndPackage.txt | 9 +++++++++ .../jet/checkers/JetDiagnosticsTestGenerated.java | 5 +++++ 3 files changed, 26 insertions(+) create mode 100644 compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt create mode 100644 compiler/testData/lazyResolve/diagnostics/overload/AmbiguityBetweenRootAndPackage.txt diff --git a/compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt b/compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt new file mode 100644 index 00000000000..a1c71570df3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt @@ -0,0 +1,12 @@ +// FILE: checkAmbiguityBetweenRootAndPackage.kt +package test + +val t = testFun() + +// FILE: checkAmbiguityBetweenRootAndPackageRoot.kt +fun testFun() = 12 + +// FILE: checkAmbiguityBetweenRootAndPackageTest.kt +package test + +fun testFun() = 12 \ No newline at end of file diff --git a/compiler/testData/lazyResolve/diagnostics/overload/AmbiguityBetweenRootAndPackage.txt b/compiler/testData/lazyResolve/diagnostics/overload/AmbiguityBetweenRootAndPackage.txt new file mode 100644 index 00000000000..95a3b32216c --- /dev/null +++ b/compiler/testData/lazyResolve/diagnostics/overload/AmbiguityBetweenRootAndPackage.txt @@ -0,0 +1,9 @@ +namespace + +// +namespace test + +internal final val t: [ERROR : Type for testFun()] +internal final fun testFun(): jet.Int +// +internal final fun testFun(): jet.Int diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 9ccce46684d..6586b0479d4 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -3810,6 +3810,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/scopes"), "kt", true); } + @TestMetadata("AmbiguityBetweenRootAndPackage.kt") + public void testAmbiguityBetweenRootAndPackage() throws Exception { + doTest("compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt"); + } + @TestMetadata("ImportFromCurrentWithDifferentName.kt") public void testImportFromCurrentWithDifferentName() throws Exception { doTest("compiler/testData/diagnostics/tests/scopes/ImportFromCurrentWithDifferentName.kt"); From d4e3a4f74d3c1a7d1af043d8ff11a6fe2d8b5a9b Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 28 Dec 2012 18:26:54 +0400 Subject: [PATCH 16/38] Tests added for checking two-phase (classes and functions) import resolution --- .../importFunctionWithAllUnderImport.kt | 13 +++++++++++++ .../importFunctionWithAllUnderImport.txt | 7 +++++++ .../propertyClassFileDependencyRecursion.kt | 17 +++++++++++++++++ .../propertyClassFileDependencyRecursion.txt | 7 +++++++ ...yResolveNamespaceComparingTestGenerated.java | 10 ++++++++++ 5 files changed, 54 insertions(+) create mode 100644 compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.kt create mode 100644 compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.txt create mode 100644 compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.kt create mode 100644 compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.txt diff --git a/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.kt b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.kt new file mode 100644 index 00000000000..a584743dff1 --- /dev/null +++ b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.kt @@ -0,0 +1,13 @@ +// FILE: importFunctionWithAllUnderImport.kt +package test + +import testOther.* + +class B: A() +val inferTypeFromImportedFun = testFun() + +// FILE: importFunctionWithAllUnderImportOther.kt +package testOther + +open class A +fun testFun() = 1 \ No newline at end of file diff --git a/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.txt b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.txt new file mode 100644 index 00000000000..2663b8de892 --- /dev/null +++ b/compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.txt @@ -0,0 +1,7 @@ +package test + +internal val inferTypeFromImportedFun : jet.Int + +internal final class B : testOther.A { + /*primary*/ public constructor B() +} diff --git a/compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.kt b/compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.kt new file mode 100644 index 00000000000..92a05929628 --- /dev/null +++ b/compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.kt @@ -0,0 +1,17 @@ +// FILE: propertyClassFileDependencyRecursion.kt +package test + +import other.prop + +// Note: "prop" is expected to be unresolved and replaced to Any +class PropType: prop + +// Note: this time "prop" should be resolved and type should be inferred for "checkTypeProp" +val checkTypeProp = prop + +// FILE: propertyClassFileDependencyRecursionOther.kt +package other + +import test.PropType + +val prop: PropType? = null diff --git a/compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.txt b/compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.txt new file mode 100644 index 00000000000..165e96fddf4 --- /dev/null +++ b/compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.txt @@ -0,0 +1,7 @@ +package test + +internal val checkTypeProp : test.PropType? + +internal final class PropType { + /*primary*/ public constructor PropType() +} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index c62f7876825..d828335ef85 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -1952,6 +1952,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/genericFunction.kt"); } + @TestMetadata("importFunctionWithAllUnderImport.kt") + public void testImportFunctionWithAllUnderImport() throws Exception { + doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImport.kt"); + } + @TestMetadata("importFunctionWithAllUnderImportAfterNamedImport.kt") public void testImportFunctionWithAllUnderImportAfterNamedImport() throws Exception { doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/importFunctionWithAllUnderImportAfterNamedImport.kt"); @@ -1982,6 +1987,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/packageLevelObject.kt"); } + @TestMetadata("propertyClassFileDependencyRecursion.kt") + public void testPropertyClassFileDependencyRecursion() throws Exception { + doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/propertyClassFileDependencyRecursion.kt"); + } + @TestMetadata("simpleClass.kt") public void testSimpleClass() throws Exception { doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/simpleClass.kt"); From f05de2ffc82ca2b0788bcfb5edccc93eaa80c9fd Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 27 Dec 2012 18:48:03 +0400 Subject: [PATCH 17/38] KT-3165 Weird stack overflow in IDE (test added) --- ...oStackOverflowInImportInnerClassInCurrentFile.kt | 13 +++++++++++++ ...oStackOverflowInImportInnerClassInCurrentFile.kt | 13 +++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 idea/testData/quickfix/autoImports/afterCheckNoStackOverflowInImportInnerClassInCurrentFile.kt create mode 100644 idea/testData/quickfix/autoImports/beforeCheckNoStackOverflowInImportInnerClassInCurrentFile.kt diff --git a/idea/testData/quickfix/autoImports/afterCheckNoStackOverflowInImportInnerClassInCurrentFile.kt b/idea/testData/quickfix/autoImports/afterCheckNoStackOverflowInImportInnerClassInCurrentFile.kt new file mode 100644 index 00000000000..bee676f3fed --- /dev/null +++ b/idea/testData/quickfix/autoImports/afterCheckNoStackOverflowInImportInnerClassInCurrentFile.kt @@ -0,0 +1,13 @@ +// "Import Class" "false" + +// KT-3165 Weird stack overflow in IDE +// ERROR: Unresolved reference: Bar +// ERROR: Unresolved reference: SomeImpossibleName + +import Foo.Bar + +class Foo + +fun f() { + SomeImpossibleName +} \ No newline at end of file diff --git a/idea/testData/quickfix/autoImports/beforeCheckNoStackOverflowInImportInnerClassInCurrentFile.kt b/idea/testData/quickfix/autoImports/beforeCheckNoStackOverflowInImportInnerClassInCurrentFile.kt new file mode 100644 index 00000000000..bee676f3fed --- /dev/null +++ b/idea/testData/quickfix/autoImports/beforeCheckNoStackOverflowInImportInnerClassInCurrentFile.kt @@ -0,0 +1,13 @@ +// "Import Class" "false" + +// KT-3165 Weird stack overflow in IDE +// ERROR: Unresolved reference: Bar +// ERROR: Unresolved reference: SomeImpossibleName + +import Foo.Bar + +class Foo + +fun f() { + SomeImpossibleName +} \ No newline at end of file From a15f1c8946fbdf02dc7e60993adc4bc58bc6905d Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Sat, 29 Dec 2012 16:46:19 +0400 Subject: [PATCH 18/38] Test are imported functions completed --- .../basic/multifile/CompleteImportedFunction-1.kt | 9 +++++++++ .../basic/multifile/CompleteImportedFunction-2.kt | 3 +++ .../jet/completion/JetCompletionMultiTestBase.java | 2 +- .../jet/completion/JetMultifileBasicCompletionTest.java | 4 ++++ 4 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 idea/testData/completion/basic/multifile/CompleteImportedFunction-1.kt create mode 100644 idea/testData/completion/basic/multifile/CompleteImportedFunction-2.kt diff --git a/idea/testData/completion/basic/multifile/CompleteImportedFunction-1.kt b/idea/testData/completion/basic/multifile/CompleteImportedFunction-1.kt new file mode 100644 index 00000000000..e8c3d43f572 --- /dev/null +++ b/idea/testData/completion/basic/multifile/CompleteImportedFunction-1.kt @@ -0,0 +1,9 @@ +package first + +import second.testFun + +fun test() { + te +} + +// EXIST: testFun \ No newline at end of file diff --git a/idea/testData/completion/basic/multifile/CompleteImportedFunction-2.kt b/idea/testData/completion/basic/multifile/CompleteImportedFunction-2.kt new file mode 100644 index 00000000000..847e15719bd --- /dev/null +++ b/idea/testData/completion/basic/multifile/CompleteImportedFunction-2.kt @@ -0,0 +1,3 @@ +package second + +fun testFun() : Int = 12 \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/completion/JetCompletionMultiTestBase.java b/idea/tests/org/jetbrains/jet/completion/JetCompletionMultiTestBase.java index cdf8034f83e..eb3848bd51a 100644 --- a/idea/tests/org/jetbrains/jet/completion/JetCompletionMultiTestBase.java +++ b/idea/tests/org/jetbrains/jet/completion/JetCompletionMultiTestBase.java @@ -54,6 +54,6 @@ public abstract class JetCompletionMultiTestBase extends CompletionTestCase { } protected void doFileTest() { - doFileTest(1, getFileNameList()); + doFileTest(0, getFileNameList()); } } diff --git a/idea/tests/org/jetbrains/jet/completion/JetMultifileBasicCompletionTest.java b/idea/tests/org/jetbrains/jet/completion/JetMultifileBasicCompletionTest.java index 33e416b34ca..07b27813b8a 100644 --- a/idea/tests/org/jetbrains/jet/completion/JetMultifileBasicCompletionTest.java +++ b/idea/tests/org/jetbrains/jet/completion/JetMultifileBasicCompletionTest.java @@ -19,6 +19,10 @@ package org.jetbrains.jet.completion; import org.jetbrains.jet.plugin.PluginTestCaseBase; public class JetMultifileBasicCompletionTest extends JetCompletionMultiTestBase { + public void testCompleteImportedFunction() { + doFileTest(); + } + public void testCompletionOnImportedFunction() { doFileTest(); } From e69acd91989e8a848e3436b1ed508251a4e269e5 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 15 Jan 2013 21:05:18 +0400 Subject: [PATCH 19/38] JetPsiBuilder -> JetImportsFactory rename --- .../di/InjectorForTopDownAnalyzerForJvm.java | 64 +++++-------------- .../jet/di/InjectorForLazyResolve.java | 33 +++++----- .../di/InjectorForTopDownAnalyzerBasic.java | 45 ++++--------- ...PsiBuilder.java => JetImportsFactory.java} | 2 +- .../jet/lang/resolve/ImportsResolver.java | 14 ++-- .../jet/lang/resolve/lazy/ScopeProvider.java | 9 ++- .../injectors/GenerateInjectors.java | 4 +- .../di/InjectorForTopDownAnalyzerForJs.java | 45 ++++--------- 8 files changed, 75 insertions(+), 141 deletions(-) rename compiler/frontend/src/org/jetbrains/jet/lang/psi/{JetPsiBuilder.java => JetImportsFactory.java} (98%) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 5a1690d9a54..43dac4cb87f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -16,52 +16,20 @@ package org.jetbrains.jet.di; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; -import org.jetbrains.jet.lang.resolve.BodyResolver; -import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; -import org.jetbrains.jet.lang.resolve.DeclarationsChecker; -import org.jetbrains.jet.lang.resolve.DescriptorResolver; import com.intellij.openapi.project.Project; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; -import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; -import org.jetbrains.jet.lang.resolve.DeclarationResolver; -import org.jetbrains.jet.lang.resolve.AnnotationResolver; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; -import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; -import org.jetbrains.jet.lang.resolve.ImportsResolver; -import org.jetbrains.jet.lang.psi.JetPsiBuilder; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; -import org.jetbrains.jet.lang.resolve.OverloadResolver; -import org.jetbrains.jet.lang.resolve.OverrideResolver; -import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; -import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; -import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory; +import org.jetbrains.jet.lang.resolve.java.resolver.*; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; + import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ @@ -90,7 +58,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private QualifiedExpressionResolver qualifiedExpressionResolver; private CandidateResolver candidateResolver; private ImportsResolver importsResolver; - private JetPsiBuilder jetPsiBuilder; + private JetImportsFactory jetImportsFactory; private ScriptHeaderResolver scriptHeaderResolver; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; @@ -141,7 +109,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.candidateResolver = new CandidateResolver(); this.importsResolver = new ImportsResolver(); - this.jetPsiBuilder = new JetPsiBuilder(); + this.jetImportsFactory = new JetImportsFactory(); this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); @@ -242,11 +210,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); - importsResolver.setPsiBuilder(jetPsiBuilder); + importsResolver.setImportsFactory(jetImportsFactory); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); - jetPsiBuilder.setProject(project); + jetImportsFactory.setProject(project); scriptHeaderResolver.setContext(topDownAnalysisContext); scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(javaDescriptorResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 274b3b610de..f61e6a846cd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -17,20 +17,17 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; -import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.resolve.DescriptorResolver; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; -import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; -import org.jetbrains.jet.lang.resolve.AnnotationResolver; -import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; -import org.jetbrains.jet.lang.psi.JetPsiBuilder; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; +import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; + import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ @@ -46,7 +43,7 @@ public class InjectorForLazyResolve { private ScopeProvider scopeProvider; private AnnotationResolver annotationResolver; private QualifiedExpressionResolver qualifiedExpressionResolver; - private JetPsiBuilder jetPsiBuilder; + private JetImportsFactory jetImportsFactory; private CallResolver callResolver; private ArgumentTypeResolver argumentTypeResolver; private CandidateResolver candidateResolver; @@ -67,7 +64,7 @@ public class InjectorForLazyResolve { this.scopeProvider = new ScopeProvider(resolveSession); this.annotationResolver = new AnnotationResolver(); this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.jetPsiBuilder = new JetPsiBuilder(); + this.jetImportsFactory = new JetImportsFactory(); this.callResolver = new CallResolver(); this.argumentTypeResolver = new ArgumentTypeResolver(); this.candidateResolver = new CandidateResolver(); @@ -89,7 +86,7 @@ public class InjectorForLazyResolve { this.annotationResolver.setCallResolver(callResolver); this.annotationResolver.setExpressionTypingServices(expressionTypingServices); - this.jetPsiBuilder.setProject(project); + this.jetImportsFactory.setProject(project); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); @@ -131,8 +128,8 @@ public class InjectorForLazyResolve { return this.qualifiedExpressionResolver; } - public JetPsiBuilder getJetPsiBuilder() { - return this.jetPsiBuilder; + public JetImportsFactory getJetImportsFactory() { + return this.jetImportsFactory; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 03fccadbc3e..e360ebc71ec 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -16,35 +16,18 @@ package org.jetbrains.jet.di; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; -import org.jetbrains.jet.lang.resolve.BodyResolver; -import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; -import org.jetbrains.jet.lang.resolve.DeclarationsChecker; -import org.jetbrains.jet.lang.resolve.DescriptorResolver; import com.intellij.openapi.project.Project; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; -import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; -import org.jetbrains.jet.lang.resolve.DeclarationResolver; -import org.jetbrains.jet.lang.resolve.AnnotationResolver; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; -import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; -import org.jetbrains.jet.lang.resolve.ImportsResolver; -import org.jetbrains.jet.lang.psi.JetPsiBuilder; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; -import org.jetbrains.jet.lang.resolve.OverloadResolver; -import org.jetbrains.jet.lang.resolve.OverrideResolver; -import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; -import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; + import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ @@ -72,7 +55,7 @@ public class InjectorForTopDownAnalyzerBasic { private QualifiedExpressionResolver qualifiedExpressionResolver; private CandidateResolver candidateResolver; private ImportsResolver importsResolver; - private JetPsiBuilder jetPsiBuilder; + private JetImportsFactory jetImportsFactory; private ScriptHeaderResolver scriptHeaderResolver; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; @@ -108,7 +91,7 @@ public class InjectorForTopDownAnalyzerBasic { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.candidateResolver = new CandidateResolver(); this.importsResolver = new ImportsResolver(); - this.jetPsiBuilder = new JetPsiBuilder(); + this.jetImportsFactory = new JetImportsFactory(); this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); @@ -183,11 +166,11 @@ public class InjectorForTopDownAnalyzerBasic { importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); - importsResolver.setPsiBuilder(jetPsiBuilder); + importsResolver.setImportsFactory(jetImportsFactory); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); - jetPsiBuilder.setProject(project); + jetImportsFactory.setProject(project); scriptHeaderResolver.setContext(topDownAnalysisContext); scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportsFactory.java similarity index 98% rename from compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java rename to compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportsFactory.java index 5f09d3a7829..8db2349e1c0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportsFactory.java @@ -28,7 +28,7 @@ import javax.inject.Inject; import java.util.Collection; import java.util.Map; -public class JetPsiBuilder { +public class JetImportsFactory { @NotNull private Project project; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index ace34b45e2e..07f8acf889d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -48,7 +48,7 @@ public class ImportsResolver { @NotNull private BindingTrace trace; @NotNull - private JetPsiBuilder psiBuilder; + private JetImportsFactory importsFactory; @Inject public void setContext(@NotNull TopDownAnalysisContext context) { @@ -71,8 +71,8 @@ public class ImportsResolver { } @Inject - public void setPsiBuilder(@NotNull JetPsiBuilder psiBuilder) { - this.psiBuilder = psiBuilder; + public void setImportsFactory(@NotNull JetImportsFactory importsFactory) { + this.importsFactory = importsFactory; } public void processTypeImports(@NotNull JetScope rootScope) { @@ -95,18 +95,18 @@ public class ImportsResolver { } private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List directives, JetScope rootScope) { - processImportsInFile(lookupMode, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver, psiBuilder); + processImportsInFile(lookupMode, scope, directives, rootScope, configuration, trace, qualifiedExpressionResolver, importsFactory); } public static void processImportsInFile( - @NotNull LookupMode lookupMode, + LookupMode lookupMode, @NotNull WritableScope namespaceScope, @NotNull List importDirectives, @NotNull JetScope rootScope, @NotNull ModuleConfiguration configuration, @NotNull BindingTrace trace, @NotNull QualifiedExpressionResolver qualifiedExpressionResolver, - @NotNull JetPsiBuilder psiBuilder + @NotNull JetImportsFactory importsFactory ) { Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope); @@ -118,7 +118,7 @@ public class ImportsResolver { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create( trace, "transient trace to resolve default imports"); //not to trace errors of default imports - JetImportDirective defaultImportDirective = psiBuilder.createImportDirective(defaultImportPath); + JetImportDirective defaultImportDirective = importsFactory.createImportDirective(defaultImportPath); qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, namespaceScope, delayedImporter, temporaryTrace, configuration, lookupMode); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index ffb79681eaf..6045703632e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java @@ -30,7 +30,10 @@ import org.jetbrains.jet.lang.resolve.scopes.ChainedScope; import org.jetbrains.jet.lang.resolve.scopes.InnerClassesScopeWrapper; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import java.util.*; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.WeakHashMap; public class ScopeProvider { private final ResolveSession resolveSession; @@ -88,10 +91,10 @@ public class ScopeProvider { throw new IllegalStateException("Root package not found"); } - JetPsiBuilder jetPsiBuilder = resolveSession.getInjector().getJetPsiBuilder(); + JetImportsFactory importsFactory = resolveSession.getInjector().getJetImportsFactory(); List defaultImports = resolveSession.getModuleConfiguration().getDefaultImports(); - Collection defaultImportDirectives = jetPsiBuilder.createImportDirectives(defaultImports); + Collection defaultImportDirectives = importsFactory.createImportDirectives(defaultImports); return new LazyImportScope( resolveSession, diff --git a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index d9e69574a56..148f0afcc1f 100644 --- a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -25,7 +25,7 @@ import org.jetbrains.jet.di.*; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiBuilder; +import org.jetbrains.jet.lang.psi.JetImportsFactory; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; @@ -72,7 +72,7 @@ public class GenerateInjectors { generator.addPublicField(ScopeProvider.class); generator.addPublicField(AnnotationResolver.class); generator.addPublicField(QualifiedExpressionResolver.class); - generator.addPublicField(JetPsiBuilder.class); + generator.addPublicField(JetImportsFactory.class); generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", GenerateInjectors.class); } diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index a8a208476bb..4dc808ad3aa 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -16,35 +16,18 @@ package org.jetbrains.jet.di; -import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; -import org.jetbrains.jet.lang.resolve.BodyResolver; -import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; -import org.jetbrains.jet.lang.resolve.DeclarationsChecker; -import org.jetbrains.jet.lang.resolve.DescriptorResolver; import com.intellij.openapi.project.Project; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; -import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; -import org.jetbrains.jet.lang.resolve.DeclarationResolver; -import org.jetbrains.jet.lang.resolve.AnnotationResolver; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; -import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; -import org.jetbrains.jet.lang.resolve.ImportsResolver; -import org.jetbrains.jet.lang.psi.JetPsiBuilder; -import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; -import org.jetbrains.jet.lang.resolve.OverloadResolver; -import org.jetbrains.jet.lang.resolve.OverrideResolver; -import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; -import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; + import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ @@ -72,7 +55,7 @@ public class InjectorForTopDownAnalyzerForJs { private QualifiedExpressionResolver qualifiedExpressionResolver; private CandidateResolver candidateResolver; private ImportsResolver importsResolver; - private JetPsiBuilder jetPsiBuilder; + private JetImportsFactory jetImportsFactory; private ScriptHeaderResolver scriptHeaderResolver; private OverloadResolver overloadResolver; private OverrideResolver overrideResolver; @@ -108,7 +91,7 @@ public class InjectorForTopDownAnalyzerForJs { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.candidateResolver = new CandidateResolver(); this.importsResolver = new ImportsResolver(); - this.jetPsiBuilder = new JetPsiBuilder(); + this.jetImportsFactory = new JetImportsFactory(); this.scriptHeaderResolver = new ScriptHeaderResolver(); this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); @@ -183,11 +166,11 @@ public class InjectorForTopDownAnalyzerForJs { importsResolver.setConfiguration(moduleConfiguration); importsResolver.setContext(topDownAnalysisContext); - importsResolver.setPsiBuilder(jetPsiBuilder); + importsResolver.setImportsFactory(jetImportsFactory); importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver); importsResolver.setTrace(bindingTrace); - jetPsiBuilder.setProject(project); + jetImportsFactory.setProject(project); scriptHeaderResolver.setContext(topDownAnalysisContext); scriptHeaderResolver.setDependencyClassByQualifiedNameResolver(dependencyClassByQualifiedNameResolverDummy); From 54e5fa5256c650e8ae41c56c7ae28d2c174e4821 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 1 Feb 2013 21:11:43 +0400 Subject: [PATCH 20/38] Imports resolution tests --- .../jet/lang/resolve/lazy/ResolveSession.java | 4 + .../imports/ImportConflictAllPackage.resolve | 29 ++++ ...flictBetweenImportedAndRootPackage.resolve | 17 ++ ...flictBetweenImportedAndSamePackage.resolve | 20 +++ .../ImportConflictForFunctions.resolve | 29 ++++ .../ImportConflictPackageAndClass.resolve | 34 ++++ .../ImportConflictSameNameClass.resolve | 31 ++++ .../ImportConflictWithClassObject.resolve | 21 +++ .../ImportConflictWithInFileClass.resolve | 16 ++ .../ImportConflictWithInnerClass.resolve | 18 +++ .../ImportConflictsWithMappedToJava.resolve | 54 +++++++ .../imports/ImportNonBlockingAnalysis.resolve | 18 +++ .../imports/ImportResolveOrderStable.resolve | 45 ++++++ .../resolve/lazy/AbstractLazyResolveTest.java | 84 ++++++++++ .../lazy/LazyResolveFullTestGenerated.java | 98 +++++++++++ .../lazy/LazyResolveTestGenerated.java | 98 +++++++++++ .../resolve/lazy/LazyResolveTestUtil.java | 10 +- .../jet/resolve/ExpectedResolveData.java | 16 +- .../resolve/ExtensibleResolveTestCase.java | 2 +- .../resolve/JetExpectedResolveDataUtil.java | 152 ++++++++++++++++++ .../jetbrains/jet/resolve/JetResolveTest.java | 111 +------------ .../jet/generators/tests/GenerateTests.java | 6 + 22 files changed, 795 insertions(+), 118 deletions(-) create mode 100644 compiler/testData/resolve/imports/ImportConflictAllPackage.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictForFunctions.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve create mode 100644 compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve create mode 100644 compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve create mode 100644 compiler/testData/resolve/imports/ImportResolveOrderStable.resolve create mode 100644 compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java create mode 100644 compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveFullTestGenerated.java create mode 100644 compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerated.java create mode 100644 compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java index 1dfbfd7fd69..d0c1d58f902 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java @@ -128,6 +128,10 @@ public class ResolveSession { return specialClasses.apply(fqName); } + public ModuleDescriptor getRootModuleDescriptor() { + return module; + } + @NotNull /*package*/ StorageManager getStorageManager() { return storageManager; diff --git a/compiler/testData/resolve/imports/ImportConflictAllPackage.resolve b/compiler/testData/resolve/imports/ImportConflictAllPackage.resolve new file mode 100644 index 00000000000..b5485c62c34 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictAllPackage.resolve @@ -0,0 +1,29 @@ +//FILE:mainToSecond.kt +//---------------------------------------------------------------------------------- +package test + +import testing.first.* +import testing.second.* + +val a1: `second`TestClass? = null + +//FILE:mainToFirst.kt +//---------------------------------------------------------------------------------- +package test + +import testing.second.* +import testing.first.* + +val a2: `first`TestClass? = null + +//FILE:importFirst.kt +//---------------------------------------------------------------------------------- +package testing.first + +class ~first~TestClass + +//FILE:importSecond.kt +//---------------------------------------------------------------------------------- +package testing.second + +class ~second~TestClass \ No newline at end of file diff --git a/compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve b/compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve new file mode 100644 index 00000000000..8b4bb52f967 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve @@ -0,0 +1,17 @@ +//FILE:mainFile.jet +//---------------------------------------------------------------------------------- +package test + +import testing.* + +val a1: `fromRoot`TestClass? = null + +//FILE:fromRoot.kt +//---------------------------------------------------------------------------------- +trait ~fromRoot~TestClass + +//FILE:fromOtherPackage.kt +//---------------------------------------------------------------------------------- +package testing + +trait ~fromOtherPackage~TestClass \ No newline at end of file diff --git a/compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve b/compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve new file mode 100644 index 00000000000..939ac3b26c0 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve @@ -0,0 +1,20 @@ +//FILE:mainFile.jet +//---------------------------------------------------------------------------------- +package test + +import otherPackage.* + +val a1: `fromSamePackage`TestClass? = null + +//FILE:fromOtherPackage.kt +//---------------------------------------------------------------------------------- +package otherPackage + +trait ~fromOtherPackage~TestClass + + +//FILE:fromSamePackage.kt +//---------------------------------------------------------------------------------- +package test + +class ~fromSamePackage~TestClass \ No newline at end of file diff --git a/compiler/testData/resolve/imports/ImportConflictForFunctions.resolve b/compiler/testData/resolve/imports/ImportConflictForFunctions.resolve new file mode 100644 index 00000000000..c0c040d6eb3 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictForFunctions.resolve @@ -0,0 +1,29 @@ +//FILE:withAllUnderImportsSecond.kt +//---------------------------------------------------------------------------------- +package test + +import testing.first.* +import testing.second.* + +val a1 = ~second~testFun() + +//FILE:withAllUnderImportsFirst.kt +//---------------------------------------------------------------------------------- +package test + +import testing.second.* +import testing.first.* + +val a1 = ~first~testFun() + +//FILE:importFirst.kt +//---------------------------------------------------------------------------------- +package testing.first + +fun ~first~testFun(): Int = 12 + +//FILE:importSecond.kt +//---------------------------------------------------------------------------------- +package testing.second + +fun ~second~testFun(): Int = 12 \ No newline at end of file diff --git a/compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve b/compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve new file mode 100644 index 00000000000..c5c5747658e --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve @@ -0,0 +1,34 @@ +//FILE:mainToSecond.kt +//---------------------------------------------------------------------------------- +package test + +import testing.first.* +import testing.second.TestClass + +val a1: `second`TestClass? = null + + +//FILE:mainToFirst.kt +//---------------------------------------------------------------------------------- +package test + +import testing.second.TestClass +import testing.first.* + +// Single import has priority over package import +val a2: `first`TestClass? = null + + +//FILE:importFirst.kt +//---------------------------------------------------------------------------------- +package testing.first + +class ~first~TestClass + + +//FILE:importSecond.kt +//---------------------------------------------------------------------------------- +package testing.second +class testing.second + +class ~second~TestClass \ No newline at end of file diff --git a/compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve b/compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve new file mode 100644 index 00000000000..901694793f3 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve @@ -0,0 +1,31 @@ +//FILE:mainToSecond.kt +//---------------------------------------------------------------------------------- +package test + +import testing.first.TestClass +import testing.second.TestClass + +val a1: `second`TestClass? = null + +//FILE:mainToFirst.kt +//---------------------------------------------------------------------------------- +package test + +import testing.second.TestClass +import testing.first.TestClass + +val a2: `first`TestClass? = null + +//FILE:importFirst.kt +//---------------------------------------------------------------------------------- +package testing.first + +class ~first~TestClass + + +//FILE:importSecond.kt +//---------------------------------------------------------------------------------- +package testing.second +class testing.second + +class ~second~TestClass \ No newline at end of file diff --git a/compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve b/compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve new file mode 100644 index 00000000000..097946d6ba6 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve @@ -0,0 +1,21 @@ +//FILE:classObject.kt +//---------------------------------------------------------------------------------- +package test + +import testing.TestClass + +class WithClassObject { + class object { + class ~class-object~TestClass + } + + // TODO: Isn't it a bug? + val a2: `testing`TestClass? = null +} + + +//FILE:testing.kt +//---------------------------------------------------------------------------------- +package testing + +class ~testing~TestClass diff --git a/compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve b/compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve new file mode 100644 index 00000000000..f31231a72cf --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve @@ -0,0 +1,16 @@ +//FILE:sameFile.kt +//---------------------------------------------------------------------------------- +package test + +import testing.TestClass + +class ~same-file~TestClass + +val a1: `same-file`TestClass? = null + + +//FILE:testing.kt +//---------------------------------------------------------------------------------- +package testing + +class ~testing~TestClass diff --git a/compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve b/compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve new file mode 100644 index 00000000000..6864e259b98 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve @@ -0,0 +1,18 @@ +//FILE:insideClass.kt +//---------------------------------------------------------------------------------- +package test + +import testing.TestClass + +class WithInnerClass { + inner class ~inner-class~TestClass + + val a3: `inner-class`TestClass? = null +} + + +//FILE:testing.kt +//---------------------------------------------------------------------------------- +package testing + +class ~testing~TestClass diff --git a/compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve b/compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve new file mode 100644 index 00000000000..2f1c0a696e4 --- /dev/null +++ b/compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve @@ -0,0 +1,54 @@ +//FILE:allPackageImport.kt +//---------------------------------------------------------------------------------- +package test + +import testing.custom.* + +// Non default import has priority over default one. No conflicts are expected. +val a1: `custom`List? = null + +//FILE:javaUtilImport.kt +//---------------------------------------------------------------------------------- +package test + +import java.util.* + +// Mapped declarations are dropped from on-demand imports. +// TODO: Fix for lazy resolve test +// val a2: 'kotlin::List'List? = null + +//FILE:allPackageWithJavaUtilImport.kt +//---------------------------------------------------------------------------------- +package test + +import testing.custom.* +import java.util.* + +// Mapped declarations are dropped from on-demand "java.util" import. So no conflicts are expected. +val a3: `custom`List? = null + +//FILE:singleClassImportFromJavaUtil.kt +//---------------------------------------------------------------------------------- +package test + +import java.util.List + +// Single import doesn't processed with Java->Kotlin class mapper. This is the way how +// java classes can be imported. +val a4: `java::java.util.List`List? = null + +//FILE:singleClassImport.kt +//---------------------------------------------------------------------------------- +package test + +import testing.custom.List + +// Single import doesn't processed with Java->Kotlin class mapper +val a5: `custom`List? = null + + +//FILE:importFirst.kt +//---------------------------------------------------------------------------------- +package testing.custom + +class ~custom~List \ No newline at end of file diff --git a/compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve b/compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve new file mode 100644 index 00000000000..94a35f57eac --- /dev/null +++ b/compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve @@ -0,0 +1,18 @@ +//FILE:firstOrder.kt +//---------------------------------------------------------------------------------- +package test + +import testing.InTesting2 +import testing.InTesting1 + +trait ~InTest1~InTest1 : `InTesting1`InTesting1 +trait ~InTest2~InTest2 : `InTesting2`InTesting2 + +//FILE:testing.kt +//---------------------------------------------------------------------------------- +package testing + +import test.InTest2 + +trait ~InTesting1~InTesting1 : `InTest2`InTest2 +trait ~InTesting2~InTesting2 diff --git a/compiler/testData/resolve/imports/ImportResolveOrderStable.resolve b/compiler/testData/resolve/imports/ImportResolveOrderStable.resolve new file mode 100644 index 00000000000..d883216630d --- /dev/null +++ b/compiler/testData/resolve/imports/ImportResolveOrderStable.resolve @@ -0,0 +1,45 @@ +//FILE:firstOrder.kt +//---------------------------------------------------------------------------------- +package test + +import testing.other.* +import testing.exact.Second +import testing.allUnder.* + +// The goal is to activate lazy resolve in order Second, Other +class FirstOrder: `other`Other, FirstInternal +trait FirstInternal: `allUnder`Second + + + +//FILE:secondOrder.kt +//---------------------------------------------------------------------------------- +package test + +import testing.other.* +import testing.exact.Second +import testing.allUnder.* + +// The goal is to activate lazy resolve in order Other, Second +class FirstOrder: FirstInternal, `other`Other +trait FirstInternal: `allUnder`Second + + + +//FILE:secondForAllUnderImport.kt +//---------------------------------------------------------------------------------- +package testing.allUnder + +trait ~allUnder~Second + +//FILE:secondForExactImport.kt +//---------------------------------------------------------------------------------- +package testing.exact + +trait ~exact~Second + +//FILE:someOther.kt +//---------------------------------------------------------------------------------- +package testing.other + +trait ~other~Other \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java new file mode 100644 index 00000000000..28a811b2e05 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java @@ -0,0 +1,84 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.lazy; + +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.io.FileUtil; +import junit.framework.Assert; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.JetLiteFixture; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.resolve.ExpectedResolveData; +import org.jetbrains.jet.resolve.JetExpectedResolveDataUtil; + +import java.io.File; +import java.util.List; + +public abstract class AbstractLazyResolveTest extends JetLiteFixture { + private ExpectedResolveData expectedResolveData; + + @Override + protected JetCoreEnvironment createEnvironment() { + return createEnvironmentWithMockJdk(ConfigurationKind.JDK_AND_ANNOTATIONS); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + expectedResolveData = getExpectedResolveData(); + } + + protected ExpectedResolveData getExpectedResolveData() { + Project project = getProject(); + + return new ExpectedResolveData( + JetExpectedResolveDataUtil.prepareDefaultNameToDescriptors(project), + JetExpectedResolveDataUtil.prepareDefaultNameToDeclaration(project), + getEnvironment()) { + @Override + protected JetFile createJetFile(String fileName, String text) { + return createCheckAndReturnPsiFile(fileName, null, text); + } + }; + } + + protected void doTest(@NonNls String testFile) throws Exception { + String text = FileUtil.loadFile(new File(testFile), true); + + List files = JetTestUtils.createTestFiles("file.kt", text, new JetTestUtils.TestFileFactory() { + @Override + public JetFile create(String fileName, String text) { + return expectedResolveData.createFileFromMarkedUpText(fileName, text); + } + }); + + ResolveSession resolveSession = LazyResolveTestUtil.resolveLazilyWithSession(files, getEnvironment()); + + NamespaceDescriptor actual = resolveSession.getPackageDescriptor(Name.identifier("test")); + Assert.assertNotNull("Package 'test' was not found", actual); + + resolveSession.forceResolveAll(); + + expectedResolveData.checkResult(resolveSession.getBindingContext()); + } + +} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveFullTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveFullTestGenerated.java new file mode 100644 index 00000000000..ae67c10aeab --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveFullTestGenerated.java @@ -0,0 +1,98 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.lazy; + +import junit.framework.Assert; +import junit.framework.Test; +import junit.framework.TestSuite; + +import java.io.File; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.test.InnerTestClasses; +import org.jetbrains.jet.test.TestMetadata; + +import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveTest; + +/** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/resolve/imports") +public class LazyResolveFullTestGenerated extends AbstractLazyResolveTest { + public void testAllFilesPresentInImports() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/imports"), "resolve", false); + } + + @TestMetadata("ImportConflictAllPackage.resolve") + public void testImportConflictAllPackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictAllPackage.resolve"); + } + + @TestMetadata("ImportConflictBetweenImportedAndRootPackage.resolve") + public void testImportConflictBetweenImportedAndRootPackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve"); + } + + @TestMetadata("ImportConflictBetweenImportedAndSamePackage.resolve") + public void testImportConflictBetweenImportedAndSamePackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve"); + } + + @TestMetadata("ImportConflictForFunctions.resolve") + public void testImportConflictForFunctions() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictForFunctions.resolve"); + } + + @TestMetadata("ImportConflictPackageAndClass.resolve") + public void testImportConflictPackageAndClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve"); + } + + @TestMetadata("ImportConflictSameNameClass.resolve") + public void testImportConflictSameNameClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve"); + } + + @TestMetadata("ImportConflictWithClassObject.resolve") + public void testImportConflictWithClassObject() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve"); + } + + @TestMetadata("ImportConflictWithInFileClass.resolve") + public void testImportConflictWithInFileClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve"); + } + + @TestMetadata("ImportConflictWithInnerClass.resolve") + public void testImportConflictWithInnerClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve"); + } + + @TestMetadata("ImportConflictsWithMappedToJava.resolve") + public void testImportConflictsWithMappedToJava() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve"); + } + + @TestMetadata("ImportNonBlockingAnalysis.resolve") + public void testImportNonBlockingAnalysis() throws Exception { + doTest("compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve"); + } + + @TestMetadata("ImportResolveOrderStable.resolve") + public void testImportResolveOrderStable() throws Exception { + doTest("compiler/testData/resolve/imports/ImportResolveOrderStable.resolve"); + } + +} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerated.java new file mode 100644 index 00000000000..98f14dfe5b2 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerated.java @@ -0,0 +1,98 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.lazy; + +import junit.framework.Assert; +import junit.framework.Test; +import junit.framework.TestSuite; + +import java.io.File; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.test.InnerTestClasses; +import org.jetbrains.jet.test.TestMetadata; + +import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveTest; + +/** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/resolve/imports") +public class LazyResolveTestGenerated extends AbstractLazyResolveTest { + public void testAllFilesPresentInImports() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/resolve/imports"), "resolve", false); + } + + @TestMetadata("ImportConflictAllPackage.resolve") + public void testImportConflictAllPackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictAllPackage.resolve"); + } + + @TestMetadata("ImportConflictBetweenImportedAndRootPackage.resolve") + public void testImportConflictBetweenImportedAndRootPackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndRootPackage.resolve"); + } + + @TestMetadata("ImportConflictBetweenImportedAndSamePackage.resolve") + public void testImportConflictBetweenImportedAndSamePackage() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictBetweenImportedAndSamePackage.resolve"); + } + + @TestMetadata("ImportConflictForFunctions.resolve") + public void testImportConflictForFunctions() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictForFunctions.resolve"); + } + + @TestMetadata("ImportConflictPackageAndClass.resolve") + public void testImportConflictPackageAndClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictPackageAndClass.resolve"); + } + + @TestMetadata("ImportConflictSameNameClass.resolve") + public void testImportConflictSameNameClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictSameNameClass.resolve"); + } + + @TestMetadata("ImportConflictWithClassObject.resolve") + public void testImportConflictWithClassObject() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithClassObject.resolve"); + } + + @TestMetadata("ImportConflictWithInFileClass.resolve") + public void testImportConflictWithInFileClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithInFileClass.resolve"); + } + + @TestMetadata("ImportConflictWithInnerClass.resolve") + public void testImportConflictWithInnerClass() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictWithInnerClass.resolve"); + } + + @TestMetadata("ImportConflictsWithMappedToJava.resolve") + public void testImportConflictsWithMappedToJava() throws Exception { + doTest("compiler/testData/resolve/imports/ImportConflictsWithMappedToJava.resolve"); + } + + @TestMetadata("ImportNonBlockingAnalysis.resolve") + public void testImportNonBlockingAnalysis() throws Exception { + doTest("compiler/testData/resolve/imports/ImportNonBlockingAnalysis.resolve"); + } + + @TestMetadata("ImportResolveOrderStable.resolve") + public void testImportResolveOrderStable() throws Exception { + doTest("compiler/testData/resolve/imports/ImportResolveOrderStable.resolve"); + } + +} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index f4d90395eaa..e0e942e93d6 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -82,7 +82,7 @@ public class LazyResolveTestUtil { return module; } - public static ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment) { + public static ResolveSession resolveLazilyWithSession(List files, JetCoreEnvironment environment) { JetTestUtils.newTrace(environment); ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("")); @@ -136,9 +136,11 @@ public class LazyResolveTestUtil { }; ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); - ResolveSession - session = new ResolveSession(project, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory); - return lazyModule; + return new ResolveSession(project, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, sharedTrace); + } + + public static ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment) { + return resolveLazilyWithSession(files, environment).getRootModuleDescriptor(); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 52ac02136f8..f3642dce155 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -143,18 +143,22 @@ public abstract class ExpectedResolveData { protected abstract JetFile createJetFile(String fileName, String text); - public final void checkResult(List files) { + protected BindingContext analyze(List files) { if (files.isEmpty()) { System.err.println("Suspicious: no files"); - return; + return BindingContext.EMPTY; } - final Set unresolvedReferences = Sets.newHashSet(); + Project project = files.iterator().next().getProject(); + AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( + project, files, Collections.emptyList(), Predicates.alwaysTrue()); + return analyzeExhaust.getBindingContext(); + } + + public final void checkResult(BindingContext bindingContext) { KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); - AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, - Collections.emptyList(), Predicates.alwaysTrue()); - BindingContext bindingContext = analyzeExhaust.getBindingContext(); + final Set unresolvedReferences = Sets.newHashSet(); for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) { unresolvedReferences.add(diagnostic.getPsiElement()); diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java index c5eabef9412..6784d4ebb0a 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java @@ -55,6 +55,6 @@ public abstract class ExtensibleResolveTestCase extends JetLiteFixture { return expectedResolveData.createFileFromMarkedUpText(fileName, text); } }); - expectedResolveData.checkResult(files); + expectedResolveData.checkResult(expectedResolveData.analyze(files)); } } diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java new file mode 100644 index 00000000000..ab822d7170a --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java @@ -0,0 +1,152 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.resolve; + +import com.intellij.openapi.project.Project; +import com.intellij.psi.*; +import junit.framework.Assert; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; +import org.jetbrains.jet.di.InjectorForTests; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; +import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.resolveFakeCall; + +public class JetExpectedResolveDataUtil { + private JetExpectedResolveDataUtil() { + } + + public static Map prepareDefaultNameToDescriptors(Project project) { + KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); + + Map nameToDescriptor = new HashMap(); + nameToDescriptor.put("kotlin::Int.plus(Int)", standardFunction(builtIns.getInt(), "plus", project, builtIns.getIntType())); + FunctionDescriptor descriptorForGet = standardFunction(builtIns.getArray(), "get", project, builtIns.getIntType()); + nameToDescriptor.put("kotlin::Array.get(Int)", descriptorForGet.getOriginal()); + nameToDescriptor.put("kotlin::Int.compareTo(Double)", standardFunction(builtIns.getInt(), "compareTo", project, builtIns.getDoubleType())); + @NotNull + FunctionDescriptor descriptorForSet = standardFunction(builtIns.getArray(), "set", project, builtIns.getIntType(), builtIns.getIntType()); + nameToDescriptor.put("kotlin::Array.set(Int, Int)", descriptorForSet.getOriginal()); + + return nameToDescriptor; + } + + public static Map prepareDefaultNameToDeclaration(Project project) { + Map nameToDeclaration = new HashMap(); + + PsiClass java_util_Collections = findClass("java.util.Collections", project); + nameToDeclaration.put("java::java.util.Collections.emptyList()", findMethod(java_util_Collections, "emptyList")); + nameToDeclaration.put("java::java.util.Collections", java_util_Collections); + PsiClass java_util_List = findClass("java.util.ArrayList", project); + nameToDeclaration.put("java::java.util.List", findClass("java.util.List", project)); + nameToDeclaration.put("java::java.util.ArrayList", java_util_List); + nameToDeclaration.put("java::java.util.ArrayList.set()", java_util_List.findMethodsByName("set", true)[0]); + nameToDeclaration.put("java::java.util.ArrayList.get()", java_util_List.findMethodsByName("get", true)[0]); + nameToDeclaration.put("java::java", findPackage("java", project)); + nameToDeclaration.put("java::java.util", findPackage("java.util", project)); + nameToDeclaration.put("java::java.lang", findPackage("java.lang", project)); + nameToDeclaration.put("java::java.lang.Object", findClass("java.lang.Object", project)); + nameToDeclaration.put("java::java.lang.Comparable", findClass("java.lang.Comparable", project)); + PsiClass java_lang_System = findClass("java.lang.System", project); + nameToDeclaration.put("java::java.lang.System", java_lang_System); + PsiMethod[] methods = findClass("java.io.PrintStream", project).findMethodsByName("print", true); + nameToDeclaration.put("java::java.io.PrintStream.print(Object)", methods[8]); + nameToDeclaration.put("java::java.io.PrintStream.print(Int)", methods[2]); + nameToDeclaration.put("java::java.io.PrintStream.print(char[])", methods[6]); + nameToDeclaration.put("java::java.io.PrintStream.print(Double)", methods[5]); + PsiField outField = java_lang_System.findFieldByName("out", true); + Assert.assertNotNull("'out' property wasn't found", outField); + nameToDeclaration.put("java::java.lang.System.out", outField); + PsiClass java_lang_Number = findClass("java.lang.Number", project); + nameToDeclaration.put("java::java.lang.Number", java_lang_Number); + nameToDeclaration.put("java::java.lang.Number.intValue()", java_lang_Number.findMethodsByName("intValue", true)[0]); + + return nameToDeclaration; + } + + @NotNull + private static PsiElement findPackage(String qualifiedName, Project project) { + JavaPsiFacade javaFacade = JavaPsiFacade.getInstance(project); + PsiPackage javaFacadePackage = javaFacade.findPackage(qualifiedName); + Assert.assertNotNull("Package wasn't found: " + qualifiedName, javaFacadePackage); + return javaFacadePackage; + } + + @NotNull + private static PsiMethod findMethod(PsiClass psiClass, String name) { + PsiMethod[] emptyLists = psiClass.findMethodsByName(name, true); + return emptyLists[0]; + } + + @NotNull + private static PsiClass findClass(String qualifiedName, Project project) { + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project); + PsiClass psiClass = injector.getPsiClassFinder().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.THROW); + Assert.assertNotNull("Class wasn't found: " + qualifiedName, psiClass); + return psiClass; + } + + @NotNull + private static FunctionDescriptor standardFunction( + ClassDescriptor classDescriptor, + String name, + Project project, + JetType... parameterTypes + ) { + ExpressionTypingServices expressionTypingServices = new InjectorForTests(project).getExpressionTypingServices(); + + ExpressionTypingContext context = ExpressionTypingContext.newContext( + expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(), + DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE, false); + + OverloadResolutionResults functions = resolveFakeCall( + context, ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypes); + + for (ResolvedCall resolvedCall : functions.getResultingCalls()) { + List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); + for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { + ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); + if (unsubstitutedValueParameter.getType().equals(parameterTypes[i])) { + return resolvedCall.getResultingDescriptor(); + } + } + } + throw new IllegalArgumentException("Not found: kotlin::" + classDescriptor.getName() + "." + name + "(" + + Arrays.toString(parameterTypes) + ")"); + } +} diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index faa1833287d..5ba19c671cb 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -18,42 +18,13 @@ package org.jetbrains.jet.resolve; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.project.Project; -import com.intellij.psi.JavaPsiFacade; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; import junit.framework.Test; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestCaseBuilder; -import org.jetbrains.jet.di.InjectorForJavaSemanticServices; -import org.jetbrains.jet.di.InjectorForTests; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; -import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; -import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.parsing.JetParsingTest; import java.io.File; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.resolveFakeCall; @SuppressWarnings("JUnitTestCaseWithNoTests") public class JetResolveTest extends ExtensibleResolveTestCase { @@ -70,41 +41,11 @@ public class JetResolveTest extends ExtensibleResolveTestCase { @Override protected ExpectedResolveData getExpectedResolveData() { Project project = getProject(); - KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); - Map nameToDescriptor = new HashMap(); - nameToDescriptor.put("kotlin::Int.plus(Int)", standardFunction(builtIns.getInt(), "plus", builtIns.getIntType())); - FunctionDescriptor descriptorForGet = standardFunction(builtIns.getArray(), "get", builtIns.getIntType()); - nameToDescriptor.put("kotlin::Array.get(Int)", descriptorForGet.getOriginal()); - nameToDescriptor.put("kotlin::Int.compareTo(Double)", standardFunction(builtIns.getInt(), "compareTo", builtIns.getDoubleType())); - @NotNull - FunctionDescriptor descriptorForSet = standardFunction(builtIns.getArray(), "set", builtIns.getIntType(), builtIns.getIntType()); - nameToDescriptor.put("kotlin::Array.set(Int, Int)", descriptorForSet.getOriginal()); - Map nameToDeclaration = new HashMap(); - PsiClass java_util_Collections = findClass("java.util.Collections"); - nameToDeclaration.put("java::java.util.Collections.emptyList()", findMethod(java_util_Collections, "emptyList")); - nameToDeclaration.put("java::java.util.Collections", java_util_Collections); - PsiClass java_util_List = findClass("java.util.ArrayList"); - nameToDeclaration.put("java::java.util.ArrayList", java_util_List); - nameToDeclaration.put("java::java.util.ArrayList.set()", java_util_List.findMethodsByName("set", true)[0]); - nameToDeclaration.put("java::java.util.ArrayList.get()", java_util_List.findMethodsByName("get", true)[0]); - nameToDeclaration.put("java::java", findPackage("java")); - nameToDeclaration.put("java::java.util", findPackage("java.util")); - nameToDeclaration.put("java::java.lang", findPackage("java.lang")); - nameToDeclaration.put("java::java.lang.Object", findClass("java.lang.Object")); - PsiClass java_lang_System = findClass("java.lang.System"); - nameToDeclaration.put("java::java.lang.System", java_lang_System); - PsiMethod[] methods = findClass("java.io.PrintStream").findMethodsByName("print", true); - nameToDeclaration.put("java::java.io.PrintStream.print(Object)", methods[8]); - nameToDeclaration.put("java::java.io.PrintStream.print(Int)", methods[2]); - nameToDeclaration.put("java::java.io.PrintStream.print(char[])", methods[6]); - nameToDeclaration.put("java::java.io.PrintStream.print(Double)", methods[5]); - nameToDeclaration.put("java::java.lang.System.out", java_lang_System.findFieldByName("out", true)); - PsiClass java_lang_Number = findClass("java.lang.Number"); - nameToDeclaration.put("java::java.lang.Number", java_lang_Number); - nameToDeclaration.put("java::java.lang.Number.intValue()", java_lang_Number.findMethodsByName("intValue", true)[0]); - - return new ExpectedResolveData(nameToDescriptor, nameToDeclaration, getEnvironment()) { + return new ExpectedResolveData( + JetExpectedResolveDataUtil.prepareDefaultNameToDescriptors(project), + JetExpectedResolveDataUtil.prepareDefaultNameToDeclaration(project), + getEnvironment()) { @Override protected JetFile createJetFile(String fileName, String text) { return createCheckAndReturnPsiFile(fileName, null, text); @@ -112,50 +53,6 @@ public class JetResolveTest extends ExtensibleResolveTestCase { }; } - @NotNull - private PsiElement findPackage(String qualifiedName) { - JavaPsiFacade javaFacade = JavaPsiFacade.getInstance(getProject()); - return javaFacade.findPackage(qualifiedName); - } - - @NotNull - private PsiMethod findMethod(PsiClass psiClass, String name) { - PsiMethod[] emptyLists = psiClass.findMethodsByName(name, true); - return emptyLists[0]; - } - - @NotNull - private PsiClass findClass(String qualifiedName) { - Project project = getProject(); - InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project); - return injector.getPsiClassFinder().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.THROW); - } - - @NotNull - private FunctionDescriptor standardFunction(ClassDescriptor classDescriptor, String name, JetType... parameterTypes) { - - ExpressionTypingServices expressionTypingServices = new InjectorForTests(getProject()).getExpressionTypingServices(); - - ExpressionTypingContext context = ExpressionTypingContext.newContext( - expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(), - DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE, false); - - OverloadResolutionResults functions = resolveFakeCall( - context, ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypes); - - for (ResolvedCall resolvedCall : functions.getResultingCalls()) { - List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); - for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { - ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); - if (unsubstitutedValueParameter.getType().equals(parameterTypes[i])) { - return resolvedCall.getResultingDescriptor(); - } - } - } - throw new IllegalArgumentException("Not found: kotlin::" + classDescriptor.getName() + "." + name + "(" + - Arrays.toString(parameterTypes) + ")"); - } - @Override protected String getTestDataPath() { return getHomeDirectory() + "/compiler/testData"; diff --git a/generators/org/jetbrains/jet/generators/tests/GenerateTests.java b/generators/org/jetbrains/jet/generators/tests/GenerateTests.java index 06531d5bbca..3a21acaa6d0 100644 --- a/generators/org/jetbrains/jet/generators/tests/GenerateTests.java +++ b/generators/org/jetbrains/jet/generators/tests/GenerateTests.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.codegen.generated.AbstractRangesCodegenTest; import org.jetbrains.jet.jvm.compiler.*; import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveDescriptorRendererTest; import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveNamespaceComparingTest; +import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveTest; import org.jetbrains.jet.plugin.highlighter.AbstractDeprecatedHighlightingTest; import org.jetbrains.jet.test.generator.SimpleTestClassModel; import org.jetbrains.jet.test.generator.TestClassModel; @@ -167,6 +168,11 @@ public class GenerateTests { // new SimpleTestClassModel(AbstractLazyResolveDiagnosticsTest.TEST_DATA_DIR, true, "kt", "doTest") //); + generateTest("compiler/tests", + "LazyResolveTestGenerated", + AbstractLazyResolveTest.class, + testModel("compiler/testData/resolve/imports", false, "resolve", "doTest")); + generateTest( "compiler/tests/", "LazyResolveNamespaceComparingTestGenerated", From 7716feee71163f9bab35754c54253d064e796005 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 31 Jan 2013 13:34:44 +0400 Subject: [PATCH 21/38] Fix NPE in JetPsiUtil (EA-43298) --- .../frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java | 3 +-- compiler/testData/diagnostics/tests/regressions/ea43298.kt | 3 +++ .../jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java | 5 +++++ 3 files changed, 9 insertions(+), 2 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/regressions/ea43298.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index 6dbf6d625f3..64d66416c95 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -362,8 +362,7 @@ public class JetPsiUtil { aliasName = referenceExpression != null ? referenceExpression.getReferencedName() : null; } - //noinspection ConstantConditions - return !aliasName.isEmpty() ? Name.identifier(aliasName) : null; + return aliasName != null && !aliasName.isEmpty() ? Name.identifier(aliasName) : null; } @Nullable diff --git a/compiler/testData/diagnostics/tests/regressions/ea43298.kt b/compiler/testData/diagnostics/tests/regressions/ea43298.kt new file mode 100644 index 00000000000..7a68643cae8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/regressions/ea43298.kt @@ -0,0 +1,3 @@ +import A.; + +class A diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 6586b0479d4..e26e668826a 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -3319,6 +3319,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage doTest("compiler/testData/diagnostics/tests/regressions/ea40964.kt"); } + @TestMetadata("ea43298.kt") + public void testEa43298() throws Exception { + doTest("compiler/testData/diagnostics/tests/regressions/ea43298.kt"); + } + @TestMetadata("ErrorsOnIbjectExpressionsAsParameters.kt") public void testErrorsOnIbjectExpressionsAsParameters() throws Exception { doTest("compiler/testData/diagnostics/tests/regressions/ErrorsOnIbjectExpressionsAsParameters.kt"); From 2a4f06e32d72779b40565b119d33dda8725d72ed Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 1 Feb 2013 16:26:04 +0400 Subject: [PATCH 22/38] Make the exception message in JvmClassName helpful --- .../src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java index a91357ad061..4f54eff8e42 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java @@ -38,8 +38,7 @@ public class JvmClassName { @NotNull public static JvmClassName byType(@NotNull Type type) { if (type.getSort() != Type.OBJECT) { - throw new IllegalArgumentException( - "must be an object to be converted to " + JvmClassName.class.getSimpleName()); + throw new IllegalArgumentException("Type is not convertible to " + JvmClassName.class.getSimpleName() + ": " + type); } return byInternalName(type.getInternalName()); } From 4ca522bf0e4395a77765983da20b52d8444c1de5 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 4 Feb 2013 14:44:25 +0400 Subject: [PATCH 23/38] Fix codegen of do-while condition The condition of a do-while loop can use variables declared in the loop (variables can only be declared inside a block). Previously this behaviour caused crash because after the block was generated, all variables declared inside that block were gone from myFrameMap #KT-3280 Fixed --- .../jet/codegen/ExpressionCodegen.java | 35 +++++++++++++------ .../codegen/box/controlStructures/doWhile.kt | 15 ++++++++ .../box/controlStructures/doWhileFib.kt | 12 +++++++ .../codegen/box/controlStructures/kt3280.kt | 24 +++++++++++++ .../BlackBoxCodegenTestGenerated.java | 15 ++++++++ 5 files changed, 91 insertions(+), 10 deletions(-) create mode 100644 compiler/testData/codegen/box/controlStructures/doWhile.kt create mode 100644 compiler/testData/codegen/box/controlStructures/doWhileFib.kt create mode 100644 compiler/testData/codegen/box/controlStructures/kt3280.kt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index dbf51228975..1cebd321e1f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -55,7 +55,6 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.java.JvmClassName; -import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; import org.jetbrains.jet.lang.resolve.scopes.receivers.*; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; @@ -421,22 +420,38 @@ public class ExpressionCodegen extends JetVisitor implem @Override public StackValue visitDoWhileExpression(JetDoWhileExpression expression, StackValue receiver) { - Label condition = new Label(); - v.mark(condition); + Label continueLabel = new Label(); + v.mark(continueLabel); - Label end = new Label(); + Label breakLabel = new Label(); - blockStackElements.push(new LoopBlockStackElement(end, condition, targetLabel(expression))); + blockStackElements.push(new LoopBlockStackElement(breakLabel, continueLabel, targetLabel(expression))); - gen(expression.getBody(), Type.VOID_TYPE); + JetExpression body = expression.getBody(); + JetExpression condition = expression.getCondition(); + StackValue conditionValue; - final StackValue conditionValue = gen(expression.getCondition()); - conditionValue.condJump(condition, false, v); + if (body instanceof JetBlockExpression) { + // If body's a block, it can contain variable declarations which may be used in the condition of a do-while loop. + // We handle this case separately because otherwise such variable will be out of the frame map after the block ends + List doWhileStatements = ((JetBlockExpression) body).getStatements(); - v.mark(end); + List statements = new ArrayList(doWhileStatements.size() + 1); + statements.addAll(doWhileStatements); + statements.add(condition); + + conditionValue = generateBlock(statements, true); + } + else { + gen(body, Type.VOID_TYPE); + conditionValue = gen(condition); + } + + conditionValue.condJump(continueLabel, false, v); + v.mark(breakLabel); blockStackElements.pop(); - return StackValue.onStack(Type.VOID_TYPE); + return StackValue.none(); } @Override diff --git a/compiler/testData/codegen/box/controlStructures/doWhile.kt b/compiler/testData/codegen/box/controlStructures/doWhile.kt new file mode 100644 index 00000000000..f9b776c736c --- /dev/null +++ b/compiler/testData/codegen/box/controlStructures/doWhile.kt @@ -0,0 +1,15 @@ +fun box(): String { + var x = 0 + do x++ while (x < 5) + if (x != 5) return "Fail 1 $x" + + var y = 0 + do { y++ } while (y < 5) + if (y != 5) return "Fail 2 $y" + + var z = "" + do { z += z.length } while (z.length < 5) + if (z != "01234") return "Fail 3 $z" + + return "OK" +} diff --git a/compiler/testData/codegen/box/controlStructures/doWhileFib.kt b/compiler/testData/codegen/box/controlStructures/doWhileFib.kt new file mode 100644 index 00000000000..088f74cb660 --- /dev/null +++ b/compiler/testData/codegen/box/controlStructures/doWhileFib.kt @@ -0,0 +1,12 @@ +fun box(): String { + var fx = 1 + var fy = 1 + + do { + var tmp = fy + fy = fx + fy + fx = tmp + } while (fy < 100) + + return if (fy == 144) "OK" else "Fail $fx $fy" +} diff --git a/compiler/testData/codegen/box/controlStructures/kt3280.kt b/compiler/testData/codegen/box/controlStructures/kt3280.kt new file mode 100644 index 00000000000..2a2b87a8f1c --- /dev/null +++ b/compiler/testData/codegen/box/controlStructures/kt3280.kt @@ -0,0 +1,24 @@ +fun foo() { + var x = 0 + do { + x++ + var y = x + 5 + } while (y < 10) + if (x != 5) throw AssertionError("$x") +} + +fun bar() { + var b = false + do { + var x = "X" + var y = "Y" + b = true + } while (x + y != "XY") + if (!b) throw AssertionError() +} + +fun box(): String { + foo() + bar() + return "OK" +} diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java index 79a2fe432e3..f474b2273dc 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java @@ -1012,6 +1012,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { blackBoxFileByFullPath("compiler/testData/codegen/box/controlStructures/continueToLabelInFor.kt"); } + @TestMetadata("doWhile.kt") + public void testDoWhile() throws Exception { + blackBoxFileByFullPath("compiler/testData/codegen/box/controlStructures/doWhile.kt"); + } + + @TestMetadata("doWhileFib.kt") + public void testDoWhileFib() throws Exception { + blackBoxFileByFullPath("compiler/testData/codegen/box/controlStructures/doWhileFib.kt"); + } + @TestMetadata("finallyOnEmptyReturn.kt") public void testFinallyOnEmptyReturn() throws Exception { blackBoxFileByFullPath("compiler/testData/codegen/box/controlStructures/finallyOnEmptyReturn.kt"); @@ -1157,6 +1167,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { blackBoxFileByFullPath("compiler/testData/codegen/box/controlStructures/kt3273.kt"); } + @TestMetadata("kt3280.kt") + public void testKt3280() throws Exception { + blackBoxFileByFullPath("compiler/testData/codegen/box/controlStructures/kt3280.kt"); + } + @TestMetadata("kt416.kt") public void testKt416() throws Exception { blackBoxFileByFullPath("compiler/testData/codegen/box/controlStructures/kt416.kt"); From ae5aeef14716d23ccfce2bb8df525c231e2ce5b2 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 4 Feb 2013 14:36:08 +0400 Subject: [PATCH 24/38] Enable parameter assertions in BytecodeToolwindow --- .../jet/plugin/internal/codewindow/BytecodeToolwindow.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java b/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java index 90c912674ab..2551f8d810e 100644 --- a/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java +++ b/idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java @@ -33,6 +33,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.codegen.*; import org.jetbrains.jet.codegen.state.GenerationState; +import org.jetbrains.jet.codegen.state.Progress; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.plugin.internal.Location; import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; @@ -90,7 +91,8 @@ public class BytecodeToolwindow extends JPanel implements Disposable { if (exhaust.isError()) { return printStackTraceToString(exhaust.getError()); } - state = new GenerationState(jetFile.getProject(), ClassBuilderFactories.TEXT, exhaust.getBindingContext(), Collections.singletonList(jetFile)); + state = new GenerationState(jetFile.getProject(), ClassBuilderFactories.TEXT, Progress.DEAF, exhaust.getBindingContext(), + Collections.singletonList(jetFile), BuiltinToJavaTypesMapping.ENABLED, true, true, true); KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION); } catch (ProcessCanceledException e) { @@ -104,7 +106,7 @@ public class BytecodeToolwindow extends JPanel implements Disposable { final ClassFileFactory factory = state.getFactory(); for (String filename : factory.files()) { - answer.append("// ================ "); + answer.append("// ================"); answer.append(filename); answer.append(" =================\n"); answer.append(factory.asText(filename)).append("\n\n"); From a47ff5cdb570889cb41997f47ea9fde023cc50e5 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 4 Feb 2013 15:37:41 +0400 Subject: [PATCH 25/38] Update to IDEA 12.0.3 --- update_dependencies.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index 4651dd8e149..688262e218b 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -3,14 +3,14 @@ From 4be1e7d8d8140c07e145565e1c5eec101fac8922 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 1 Feb 2013 13:55:01 +0400 Subject: [PATCH 26/38] Checking redundant/conflicting projection kind in alt signatures. --- .../TypeTransformingVisitor.java | 42 +++++++++++++------ .../MethodWithMappedClasses.java | 4 +- .../MethodWithMappedClasses.kt | 2 +- .../MethodWithMappedClasses.txt | 2 +- .../MethodWithTypeParameters.java | 2 +- .../MethodWithTypeParameters.kt | 2 +- .../MethodWithTypeParameters.txt | 2 +- .../error/ConflictingProjectionKind.java | 15 +++++++ .../error/ConflictingProjectionKind.kt | 7 ++++ .../error/ConflictingProjectionKind.txt | 6 +++ .../error/RedundantProjectionKind.java | 14 +++++++ .../error/RedundantProjectionKind.kt | 7 ++++ .../error/RedundantProjectionKind.txt | 6 +++ .../jvm/compiler/LoadJavaTestGenerated.java | 10 +++++ ...esolveNamespaceComparingTestGenerated.java | 10 +++++ 15 files changed, 111 insertions(+), 20 deletions(-) create mode 100644 compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.java create mode 100644 compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.kt create mode 100644 compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.txt create mode 100644 compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.java create mode 100644 compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.kt create mode 100644 compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.txt diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java index 84d27fb1d12..bdbaf195bb0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java @@ -25,7 +25,10 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap; +import org.jetbrains.jet.lang.resolve.java.JvmClassName; +import org.jetbrains.jet.lang.resolve.java.KotlinToJavaTypesMap; +import org.jetbrains.jet.lang.resolve.java.TypeUsage; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -33,7 +36,8 @@ import org.jetbrains.jet.renderer.DescriptorRenderer; import java.util.*; -import static org.jetbrains.jet.lang.resolve.java.TypeUsage.*; +import static org.jetbrains.jet.lang.resolve.java.TypeUsage.TYPE_ARGUMENT; +import static org.jetbrains.jet.lang.types.Variance.INVARIANT; class TypeTransformingVisitor extends JetVisitor { private final JetType originalType; @@ -113,6 +117,18 @@ class TypeTransformingVisitor extends JetVisitor { throw new AlternativeSignatureMismatchException("Alternative signature type mismatch, expected: %s, actual: %s", qualifiedName, fqName); } + TypeConstructor typeConstructor; + if (classFromLibrary != null) { + typeConstructor = classFromLibrary.getTypeConstructor(); + } + else { + typeConstructor = originalTypeConstructor; + } + ClassifierDescriptor typeConstructorClassifier = typeConstructor.getDeclarationDescriptor(); + if (typeConstructorClassifier instanceof TypeParameterDescriptor && originalToAltTypeParameters.containsKey(typeConstructorClassifier)) { + typeConstructor = originalToAltTypeParameters.get(typeConstructorClassifier).getTypeConstructor(); + } + List arguments = originalType.getArguments(); if (arguments.size() != type.getTypeArgumentsAsTypes().size()) { @@ -138,6 +154,7 @@ class TypeTransformingVisitor extends JetVisitor { JetTypeElement argumentAlternativeTypeElement = typeReference.getTypeElement(); assert argumentAlternativeTypeElement != null; + TypeParameterDescriptor parameter = typeConstructor.getParameters().get(i); TypeProjection argument = arguments.get(i); JetType alternativeArgumentType = computeType(argumentAlternativeTypeElement, argument.getType(), originalToAltTypeParameters, TYPE_ARGUMENT); Variance projectionKind = argument.getProjectionKind(); @@ -160,6 +177,16 @@ class TypeTransformingVisitor extends JetVisitor { throw new AlternativeSignatureMismatchException("Projection kind mismatch, actual: %s, in alternative signature: %s", projectionKind, altProjectionKind); } + if (altProjectionKind != INVARIANT && parameter.getVariance() != INVARIANT) { + if (altProjectionKind == parameter.getVariance()) { + // TODO report redundant if in strict mode + } + else { + throw new AlternativeSignatureMismatchException("Projection kind '%s' is conflicting with variance of %s", + altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); + } + altProjectionKind = projectionKind; + } } else { altProjectionKind = projectionKind; @@ -167,17 +194,6 @@ class TypeTransformingVisitor extends JetVisitor { altArguments.add(new TypeProjection(altProjectionKind, alternativeArgumentType)); } - TypeConstructor typeConstructor; - if (classFromLibrary != null) { - typeConstructor = classFromLibrary.getTypeConstructor(); - } - else { - typeConstructor = originalTypeConstructor; - } - ClassifierDescriptor typeConstructorClassifier = typeConstructor.getDeclarationDescriptor(); - if (typeConstructorClassifier instanceof TypeParameterDescriptor && originalToAltTypeParameters.containsKey(typeConstructorClassifier)) { - typeConstructor = originalToAltTypeParameters.get(typeConstructorClassifier).getTypeConstructor(); - } JetScope memberScope; if (typeConstructorClassifier instanceof TypeParameterDescriptor) { memberScope = ((TypeParameterDescriptor) typeConstructorClassifier).getUpperBoundsAsType().getMemberScope(); diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java index a243e3e199e..a549d970280 100644 --- a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java @@ -5,8 +5,8 @@ import java.util.*; import jet.runtime.typeinfo.KotlinSignature; public class MethodWithMappedClasses { - @KotlinSignature("fun copy(dest : MutableList, src : List)") - public void copy(List dest, List src) { + @KotlinSignature("fun copy(dest : MutableList, src : List)") + public void copy(List dest, List src) { throw new UnsupportedOperationException(); } } diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt index 4de303b8576..463d7420c17 100644 --- a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt @@ -3,5 +3,5 @@ package test import java.util.* public open class MethodWithMappedClasses : Object() { - public open fun copy(p0 : MutableList, p1 : List) {} + public open fun copy(p0 : MutableList, p1 : List) {} } diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt index a60e542edf7..637c5dfdaa9 100644 --- a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt @@ -2,5 +2,5 @@ package test public open class MethodWithMappedClasses : java.lang.Object { public constructor MethodWithMappedClasses() - public open fun copy(/*0*/ p0 : jet.MutableList, /*1*/ p1 : jet.List) : Unit + public open fun copy(/*0*/ p0 : jet.MutableList, /*1*/ p1 : jet.List) : Unit } diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.java b/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.java index 11515052502..62d65ed7375 100644 --- a/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.java +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.java @@ -8,7 +8,7 @@ import java.util.List; import jet.runtime.typeinfo.KotlinSignature; public class MethodWithTypeParameters { - @KotlinSignature("fun foo(a : A, b : List, c: MutableList) where B : List") + @KotlinSignature("fun foo(a : A, b : List, c: MutableList) where B : List") public > void foo(A a, List b, List list) { } } diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.kt b/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.kt index f83804504fd..d9a00220f50 100644 --- a/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.kt +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.kt @@ -3,6 +3,6 @@ package test import java.util.* public open class MethodWithTypeParameters : Object() { - public open fun foo(p0 : A, p1 : List, p2: MutableList) where B : List { + public open fun foo(p0 : A, p1 : List, p2: MutableList) where B : List { } } diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.txt b/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.txt index 97184b5de92..c84e685ad5b 100644 --- a/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.txt +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithTypeParameters.txt @@ -2,5 +2,5 @@ package test public open class MethodWithTypeParameters : java.lang.Object { public constructor MethodWithTypeParameters() - public open fun foo(/*0*/ p0 : A, /*1*/ p1 : jet.List, /*2*/ p2 : jet.MutableList) : Unit where B : java.lang.Runnable, B : jet.List + public open fun foo(/*0*/ p0 : A, /*1*/ p1 : jet.List, /*2*/ p2 : jet.MutableList) : Unit where B : java.lang.Runnable, B : jet.List } diff --git a/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.java b/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.java new file mode 100644 index 00000000000..503121326e0 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.java @@ -0,0 +1,15 @@ +package test; + +import java.lang.Number; +import java.util.*; + +import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; + +public class ConflictingProjectionKind { + @ExpectLoadError("Projection kind 'in' is conflicting with variance of jet.List") + @KotlinSignature("fun foo(list: List)") + public void foo(List list) { + throw new UnsupportedOperationException(); + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.kt b/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.kt new file mode 100644 index 00000000000..b9fbbcd766b --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.kt @@ -0,0 +1,7 @@ +package test + +public open class ConflictingProjectionKind : Object() { + public open fun foo(p0: List?) { + throw UnsupportedOperationException() + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.txt b/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.txt new file mode 100644 index 00000000000..a7e2f429fc1 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.txt @@ -0,0 +1,6 @@ +package test + +public open class ConflictingProjectionKind : java.lang.Object { + public constructor ConflictingProjectionKind() + public open fun foo(/*0*/ p0 : jet.List?) : Unit +} diff --git a/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.java b/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.java new file mode 100644 index 00000000000..d1695f6ba02 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.java @@ -0,0 +1,14 @@ +package test; + +import java.lang.Number; +import java.util.*; + +import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; + +public class RedundantProjectionKind { + @KotlinSignature("fun foo(list: List)") + public void foo(List list) { + throw new UnsupportedOperationException(); + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.kt b/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.kt new file mode 100644 index 00000000000..b241e86d29b --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.kt @@ -0,0 +1,7 @@ +package test + +public open class RedundantProjectionKind : Object() { + public open fun foo(p0: List) { + throw UnsupportedOperationException() + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.txt b/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.txt new file mode 100644 index 00000000000..3cf7a00a492 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.txt @@ -0,0 +1,6 @@ +package test + +public open class RedundantProjectionKind : java.lang.Object { + public constructor RedundantProjectionKind() + public open fun foo(/*0*/ p0 : jet.List) : Unit +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java index 5a6df8345c9..4861745c39c 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java @@ -343,6 +343,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/error"), "java", true); } + @TestMetadata("ConflictingProjectionKind.java") + public void testConflictingProjectionKind() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.java"); + } + @TestMetadata("ExplicitFieldGettersAndSetters.java") public void testExplicitFieldGettersAndSetters() throws Exception { doTest("compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java"); @@ -368,6 +373,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { doTest("compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java"); } + @TestMetadata("RedundantProjectionKind.java") + public void testRedundantProjectionKind() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.java"); + } + @TestMetadata("ReturnTypeMissing.java") public void testReturnTypeMissing() throws Exception { doTest("compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java"); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index d828335ef85..d1bbb8b546e 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -1312,6 +1312,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/error"), "kt", true); } + @TestMetadata("ConflictingProjectionKind.kt") + public void testConflictingProjectionKind() throws Exception { + doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/error/ConflictingProjectionKind.kt"); + } + @TestMetadata("ExplicitFieldGettersAndSetters.kt") public void testExplicitFieldGettersAndSetters() throws Exception { doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.kt"); @@ -1337,6 +1342,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.kt"); } + @TestMetadata("RedundantProjectionKind.kt") + public void testRedundantProjectionKind() throws Exception { + doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/error/RedundantProjectionKind.kt"); + } + @TestMetadata("ReturnTypeMissing.kt") public void testReturnTypeMissing() throws Exception { doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.kt"); From 25dc5b5991da1c32bf7f9b62f18010d60d635e4c Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 1 Feb 2013 14:29:25 +0400 Subject: [PATCH 27/38] Checking redundant projections in jdk annotations. --- .../kotlinSignature/TypeTransformingVisitor.java | 15 +++++++++++++-- .../jvm/compiler/JdkAnnotationsValidityTest.java | 15 ++++++++++++++- 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java index bdbaf195bb0..3bb68d12be9 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.kotlinSignature; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.TestOnly; import org.jetbrains.asm4.Type; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; @@ -39,7 +40,9 @@ import java.util.*; import static org.jetbrains.jet.lang.resolve.java.TypeUsage.TYPE_ARGUMENT; import static org.jetbrains.jet.lang.types.Variance.INVARIANT; -class TypeTransformingVisitor extends JetVisitor { +public class TypeTransformingVisitor extends JetVisitor { + private static boolean strictMode = false; + private final JetType originalType; private final Map originalToAltTypeParameters; @@ -179,7 +182,10 @@ class TypeTransformingVisitor extends JetVisitor { } if (altProjectionKind != INVARIANT && parameter.getVariance() != INVARIANT) { if (altProjectionKind == parameter.getVariance()) { - // TODO report redundant if in strict mode + if (strictMode) { + throw new AlternativeSignatureMismatchException("Projection kind '%s' is redundant", + altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); + } } else { throw new AlternativeSignatureMismatchException("Projection kind '%s' is conflicting with variance of %s", @@ -232,4 +238,9 @@ class TypeTransformingVisitor extends JetVisitor { private static boolean isSameName(String qualifiedName, String fullyQualifiedName) { return fullyQualifiedName.equals(qualifiedName) || fullyQualifiedName.endsWith("." + qualifiedName); } + + @TestOnly + public static void setStrictMode(boolean strictMode) { + TypeTransformingVisitor.strictMode = strictMode; + } } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java index e2eab280f6e..a5b1711a09f 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap; +import org.jetbrains.jet.lang.resolve.java.kotlinSignature.TypeTransformingVisitor; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.renderer.DescriptorRenderer; @@ -65,10 +66,22 @@ public class JdkAnnotationsValidityTest extends UsefulTestCase { return new JetCoreEnvironment(parentDisposable, configuration); } + @Override + protected void setUp() throws Exception { + super.setUp(); + TypeTransformingVisitor.setStrictMode(true); + } + + @Override + protected void tearDown() throws Exception { + TypeTransformingVisitor.setStrictMode(false); + super.tearDown(); + } + public void testNoErrorsInAlternativeSignatures() { List affectedClasses = getAffectedClasses("file://jdk-annotations"); - final Map> errors = Maps.newHashMap(); + final Map> errors = Maps.newLinkedHashMap(); for (int chunkIndex = 0; chunkIndex < affectedClasses.size() / CLASSES_IN_CHUNK + 1; chunkIndex++) { Disposable parentDisposable = CompileEnvironmentUtil.createMockDisposable(); From 7b71c66fd65c4adcb520ec1c8490ab68e6d5f1dc Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 1 Feb 2013 14:29:34 +0400 Subject: [PATCH 28/38] Fixed errors in alternative signatures. --- jdk-annotations/java/util/annotations.xml | 28 +++++++++++------------ 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/jdk-annotations/java/util/annotations.xml b/jdk-annotations/java/util/annotations.xml index 5aef5ee591b..be66af62974 100644 --- a/jdk-annotations/java/util/annotations.xml +++ b/jdk-annotations/java/util/annotations.xml @@ -235,7 +235,7 @@ - + @@ -609,7 +609,7 @@ - + @@ -833,7 +833,7 @@ - + @@ -1244,7 +1244,7 @@ - + @@ -1333,7 +1333,7 @@ - + @@ -1836,7 +1836,7 @@ - + @@ -1920,7 +1920,7 @@ - + @@ -2321,7 +2321,7 @@ - + @@ -2513,7 +2513,7 @@ - + @@ -2651,7 +2651,7 @@ - + @@ -2898,7 +2898,7 @@ - + @@ -2968,7 +2968,7 @@ - + @@ -3116,7 +3116,7 @@ - + @@ -3421,7 +3421,7 @@ - + From c09c85e86274dbf17b3b434bc49334f19854934c Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 1 Feb 2013 15:23:59 +0400 Subject: [PATCH 29/38] Minor. Simpler code. --- .../resolve/java/kotlinSignature/TypeTransformingVisitor.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java index 3bb68d12be9..6eec6b2425d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java @@ -186,12 +186,14 @@ public class TypeTransformingVisitor extends JetVisitor { throw new AlternativeSignatureMismatchException("Projection kind '%s' is redundant", altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); } + else { + altProjectionKind = projectionKind; + } } else { throw new AlternativeSignatureMismatchException("Projection kind '%s' is conflicting with variance of %s", altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); } - altProjectionKind = projectionKind; } } else { From 10df80fedadc1e6f42ce59bac7ef4c478ab537d9 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 1 Feb 2013 16:29:20 +0400 Subject: [PATCH 30/38] Minor. Extracted method. --- .../TypeTransformingVisitor.java | 125 +++++++++--------- 1 file changed, 66 insertions(+), 59 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java index 6eec6b2425d..9330249ed21 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java @@ -99,7 +99,7 @@ public class TypeTransformingVisitor extends JetVisitor { String shortName = type.getReferenceExpression().getReferencedName(); String longName = (qualifier == null ? "" : qualifier.getText() + ".") + shortName; - if (KotlinBuiltIns.getInstance().UNIT_ALIAS.getName().equals(longName)) { + if (KotlinBuiltIns.UNIT_ALIAS.getName().equals(longName)) { return visitCommonType(KotlinBuiltIns.getInstance().getTuple(0), type); } @@ -142,64 +142,7 @@ public class TypeTransformingVisitor extends JetVisitor { List altArguments = new ArrayList(); for (int i = 0, size = arguments.size(); i < size; i++) { - JetTypeReference typeReference = type.getTypeArgumentsAsTypes().get(i); - - if (typeReference == null) { - // star projection - assert type instanceof JetUserType - && ((JetUserType) type).getTypeArguments().get(i).getProjectionKind() == JetProjectionKind.STAR; - - altArguments.add(arguments.get(i)); - - continue; - } - - JetTypeElement argumentAlternativeTypeElement = typeReference.getTypeElement(); - assert argumentAlternativeTypeElement != null; - - TypeParameterDescriptor parameter = typeConstructor.getParameters().get(i); - TypeProjection argument = arguments.get(i); - JetType alternativeArgumentType = computeType(argumentAlternativeTypeElement, argument.getType(), originalToAltTypeParameters, TYPE_ARGUMENT); - Variance projectionKind = argument.getProjectionKind(); - Variance altProjectionKind; - if (type instanceof JetUserType) { - JetTypeProjection typeProjection = ((JetUserType) type).getTypeArguments().get(i); - switch (typeProjection.getProjectionKind()) { - case IN: - altProjectionKind = Variance.IN_VARIANCE; - break; - case OUT: - altProjectionKind = Variance.OUT_VARIANCE; - break; - case STAR: - throw new IllegalStateException("star projection should have been processed above"); - default: - altProjectionKind = Variance.INVARIANT; - } - if (altProjectionKind != projectionKind && projectionKind != Variance.INVARIANT) { - throw new AlternativeSignatureMismatchException("Projection kind mismatch, actual: %s, in alternative signature: %s", - projectionKind, altProjectionKind); - } - if (altProjectionKind != INVARIANT && parameter.getVariance() != INVARIANT) { - if (altProjectionKind == parameter.getVariance()) { - if (strictMode) { - throw new AlternativeSignatureMismatchException("Projection kind '%s' is redundant", - altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); - } - else { - altProjectionKind = projectionKind; - } - } - else { - throw new AlternativeSignatureMismatchException("Projection kind '%s' is conflicting with variance of %s", - altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); - } - } - } - else { - altProjectionKind = projectionKind; - } - altArguments.add(new TypeProjection(altProjectionKind, alternativeArgumentType)); + altArguments.add(getAltArgument(type, typeConstructor, i, arguments.get(i))); } JetScope memberScope; @@ -217,6 +160,70 @@ public class TypeTransformingVisitor extends JetVisitor { altArguments, memberScope); } + @NotNull + private TypeProjection getAltArgument( + @NotNull JetTypeElement type, + @NotNull TypeConstructor typeConstructor, + int i, + @NotNull TypeProjection originalArgument + ) { + JetTypeReference typeReference = type.getTypeArgumentsAsTypes().get(i); // process both function type and user type + + if (typeReference == null) { + // star projection + assert type instanceof JetUserType + && ((JetUserType) type).getTypeArguments().get(i).getProjectionKind() == JetProjectionKind.STAR; + + return originalArgument; + } + + JetTypeElement argumentAlternativeTypeElement = typeReference.getTypeElement(); + assert argumentAlternativeTypeElement != null; + + TypeParameterDescriptor parameter = typeConstructor.getParameters().get(i); + JetType alternativeArgumentType = computeType(argumentAlternativeTypeElement, originalArgument.getType(), originalToAltTypeParameters, TYPE_ARGUMENT); + Variance projectionKind = originalArgument.getProjectionKind(); + Variance altProjectionKind; + if (type instanceof JetUserType) { + JetTypeProjection typeProjection = ((JetUserType) type).getTypeArguments().get(i); + switch (typeProjection.getProjectionKind()) { + case IN: + altProjectionKind = Variance.IN_VARIANCE; + break; + case OUT: + altProjectionKind = Variance.OUT_VARIANCE; + break; + case STAR: + throw new IllegalStateException("star projection should have been processed above"); + default: + altProjectionKind = Variance.INVARIANT; + } + if (altProjectionKind != projectionKind && projectionKind != Variance.INVARIANT) { + throw new AlternativeSignatureMismatchException("Projection kind mismatch, actual: %s, in alternative signature: %s", + projectionKind, altProjectionKind); + } + if (altProjectionKind != INVARIANT && parameter.getVariance() != INVARIANT) { + if (altProjectionKind == parameter.getVariance()) { + if (strictMode) { + throw new AlternativeSignatureMismatchException("Projection kind '%s' is redundant", + altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); + } + else { + altProjectionKind = projectionKind; + } + } + else { + throw new AlternativeSignatureMismatchException("Projection kind '%s' is conflicting with variance of %s", + altProjectionKind, DescriptorUtils.getFQName(typeConstructor.getDeclarationDescriptor())); + } + } + } + else { + altProjectionKind = projectionKind; + } + return new TypeProjection(altProjectionKind, alternativeArgumentType); + } + @Nullable private ClassDescriptor getAutoTypeAnalogWithinBuiltins(String qualifiedName) { Type javaAnalog = KotlinToJavaTypesMap.getInstance().getJavaAnalog(originalType); From ffbcdb7b49a2744ab946bef37c181522b115d761 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 1 Feb 2013 17:10:38 +0400 Subject: [PATCH 31/38] EA-39239 - assert: ConfigureKotlinLibraryNotificationProvider.addJdkAnnotations --- .../jet/plugin/versions/KotlinRuntimeLibraryUtil.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/idea/src/org/jetbrains/jet/plugin/versions/KotlinRuntimeLibraryUtil.java b/idea/src/org/jetbrains/jet/plugin/versions/KotlinRuntimeLibraryUtil.java index 1adbcdd25fe..c588b7a4e77 100644 --- a/idea/src/org/jetbrains/jet/plugin/versions/KotlinRuntimeLibraryUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/versions/KotlinRuntimeLibraryUtil.java @@ -107,7 +107,9 @@ public class KotlinRuntimeLibraryUtil { public static void addJdkAnnotations(@NotNull Module module) { Sdk sdk = ModuleRootManager.getInstance(module).getSdk(); - assert sdk != null; + if (sdk == null) { + return; + } File annotationsIoFile = PathUtil.getKotlinPathsForIdeaPlugin().getJdkAnnotationsPath(); if (annotationsIoFile.exists()) { VirtualFile jdkAnnotationsJar = LocalFileSystem.getInstance().findFileByIoFile(annotationsIoFile); From 7f5dfd73197fd1c671c22a656c97a46027b8dcdc Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 1 Feb 2013 17:45:27 +0400 Subject: [PATCH 32/38] Minor. --- .../jet/plugin/libraries/JetSourceNavigationHelper.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index 1168c71498c..8cec5ee2a16 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -229,10 +229,10 @@ public class JetSourceNavigationHelper { @Nullable private static JetClassOrObject getSourceForNamedClassOrObject(@NotNull JetClassOrObject decompiledClassOrObject) { - FqName classFqName = JetPsiUtil.getFQName((JetNamedDeclaration) decompiledClassOrObject); + FqName classFqName = JetPsiUtil.getFQName(decompiledClassOrObject); assert classFqName != null; - GlobalSearchScope librarySourcesScope = createLibrarySourcesScope((JetNamedDeclaration) decompiledClassOrObject); + GlobalSearchScope librarySourcesScope = createLibrarySourcesScope(decompiledClassOrObject); if (librarySourcesScope == GlobalSearchScope.EMPTY_SCOPE) { // .getProject() == null for EMPTY_SCOPE, and this breaks code return null; } From c96c3c3d45b2684057c443f0c5333e92621ee08f Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Mon, 4 Feb 2013 15:56:28 +0400 Subject: [PATCH 33/38] Removed resources jar from classpath. It is redundant. --- build.xml | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/build.xml b/build.xml index 5516124acc0..697ab76b51b 100644 --- a/build.xml +++ b/build.xml @@ -1,7 +1,7 @@ - + @@ -15,12 +15,6 @@ - - - From d08466d2652a4e9c142652e7b6431caec70452e3 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Mon, 4 Feb 2013 16:08:41 +0400 Subject: [PATCH 34/38] Removed redundant 'out' in MutableMap.putAll --- .../jet/lang/resolve/java/JavaToKotlinMethodMapGenerated.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinMethodMapGenerated.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinMethodMapGenerated.java index a7dc856a6cf..c2c84702d7e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinMethodMapGenerated.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinMethodMapGenerated.java @@ -198,7 +198,7 @@ class JavaToKotlinMethodMapGenerated { pair("java.util.Map boolean isEmpty()", "public abstract fun isEmpty() : jet.Boolean defined in jet.MutableMap"), pair("java.util.Map java.util.Set keySet()", "public abstract fun keySet() : jet.MutableSet defined in jet.MutableMap"), pair("java.util.Map V put(K, V)", "public abstract fun put(key : K, value : V) : V? defined in jet.MutableMap"), - pair("java.util.Map void putAll(java.util.Map)", "public abstract fun putAll(m : jet.Map) : Unit defined in jet.MutableMap"), + pair("java.util.Map void putAll(java.util.Map)", "public abstract fun putAll(m : jet.Map) : Unit defined in jet.MutableMap"), pair("java.util.Map V remove(java.lang.Object)", "public abstract fun remove(key : jet.Any?) : V? defined in jet.MutableMap"), pair("java.util.Map int size()", "public abstract fun size() : jet.Int defined in jet.MutableMap"), pair("java.util.Map java.util.Collection values()", "public abstract fun values() : jet.MutableCollection defined in jet.MutableMap") From 658dbda6d4abc79697eb620016bddb94fdd47f81 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Mon, 4 Feb 2013 16:15:22 +0400 Subject: [PATCH 35/38] Regenerated injectors. --- .../di/InjectorForTopDownAnalyzerForJvm.java | 52 +++++++++++++++---- .../jet/di/InjectorForLazyResolve.java | 21 ++++---- .../di/InjectorForTopDownAnalyzerBasic.java | 33 +++++++++--- .../di/InjectorForTopDownAnalyzerForJs.java | 33 +++++++++--- 4 files changed, 104 insertions(+), 35 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 43dac4cb87f..c6a01fa1f6a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -16,20 +16,52 @@ package org.jetbrains.jet.di; +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; +import org.jetbrains.jet.lang.resolve.BodyResolver; +import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; +import org.jetbrains.jet.lang.resolve.DeclarationsChecker; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; import com.intellij.openapi.project.Project; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.psi.JetImportsFactory; -import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; +import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; +import org.jetbrains.jet.lang.resolve.DeclarationResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; -import org.jetbrains.jet.lang.resolve.java.*; -import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.java.resolver.*; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; - +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; +import org.jetbrains.jet.lang.resolve.OverloadResolver; +import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; +import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory; +import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; +import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index f61e6a846cd..6cdb2ff029a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -17,17 +17,20 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.psi.JetImportsFactory; -import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; - +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index e360ebc71ec..183b852e318 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -16,18 +16,35 @@ package org.jetbrains.jet.di; +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; +import org.jetbrains.jet.lang.resolve.BodyResolver; +import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; +import org.jetbrains.jet.lang.resolve.DeclarationsChecker; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; import com.intellij.openapi.project.Project; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.psi.JetImportsFactory; -import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; +import org.jetbrains.jet.lang.resolve.DeclarationResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; - +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; +import org.jetbrains.jet.lang.resolve.OverloadResolver; +import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; +import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 4dc808ad3aa..11193fe1503 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -16,18 +16,35 @@ package org.jetbrains.jet.di; +import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext; +import org.jetbrains.jet.lang.resolve.BodyResolver; +import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer; +import org.jetbrains.jet.lang.resolve.DeclarationsChecker; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; import com.intellij.openapi.project.Project; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.psi.JetImportsFactory; -import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; +import org.jetbrains.jet.lang.resolve.DeclarationResolver; +import org.jetbrains.jet.lang.resolve.AnnotationResolver; +import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; - +import org.jetbrains.jet.lang.resolve.TypeResolver; +import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; +import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; +import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.psi.JetImportsFactory; +import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver; +import org.jetbrains.jet.lang.resolve.OverloadResolver; +import org.jetbrains.jet.lang.resolve.OverrideResolver; +import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; +import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; +import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */ From 62bdd75c4375ac49290162e39cc8a9d6cd94b5f3 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Mon, 4 Feb 2013 16:15:49 +0400 Subject: [PATCH 36/38] Added assert message. --- .../jet/plugin/intentions/SpecifyTypeExplicitlyAction.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java index af97e547f26..3f3ca864871 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java +++ b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java @@ -84,7 +84,7 @@ public class SpecifyTypeExplicitlyAction extends PsiElementBaseIntentionAction { addTypeAnnotation(project, function, type); } else { - assert false; + throw new IllegalStateException("Unexpected parent: " + parent); } } From c9339c287106e0a31ab70bb42661cb0794ec7d5a Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 4 Feb 2013 17:12:57 +0400 Subject: [PATCH 37/38] Turn on generating not-null assertions by default When compiling from IDE --- .../org/jetbrains/jet/compiler/runner/KotlinCompilerRunner.java | 1 + 1 file changed, 1 insertion(+) diff --git a/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/KotlinCompilerRunner.java b/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/KotlinCompilerRunner.java index 3b88a69b284..1274a3df0d9 100644 --- a/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/KotlinCompilerRunner.java +++ b/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/KotlinCompilerRunner.java @@ -90,6 +90,7 @@ public class KotlinCompilerRunner { "-module", scriptFile.getAbsolutePath(), "-output", outputDir.getPath(), "-tags", "-verbose", "-version", + "-notNullAssertions", "-notNullParamAssertions", "-noStdlib", "-noJdkAnnotations", "-noJdk"}; } From 649cbb65c0f88c2166f4b1d43ea1a9e2688ffe1d Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Mon, 4 Feb 2013 17:29:56 +0400 Subject: [PATCH 38/38] Reverted proguard in build. --- build.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.xml b/build.xml index 697ab76b51b..027da9dd851 100644 --- a/build.xml +++ b/build.xml @@ -1,7 +1,7 @@ - +