diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index e15888c5e93..86b5eaa251b 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -46,13 +46,13 @@ public class AbstractLazyResolveDescriptorRendererTest extends AbstractLazyResol protected void doTest(@NotNull String testFile) throws IOException { - InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(); + InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(regularEnvironment); - JetFile psiFile = JetPsiFactory.createFile(project, FileUtil.loadFile(new File(testFile), true)); + JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true)); Collection files = Lists.newArrayList(psiFile); ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); - final ResolveSession resolveSession = new ResolveSession(project, lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(), + final ResolveSession resolveSession = new ResolveSession(getProject(), lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(), new FileBasedDeclarationProviderFactory(files)); final List descriptors = new ArrayList(); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java index be9af9d27c4..12a9801c64e 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java @@ -20,9 +20,11 @@ import com.google.common.base.Predicate; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.io.FileUtil; import com.intellij.util.Function; +import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; import org.jetbrains.jet.jvm.compiler.NamespaceComparator; +import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; @@ -48,7 +50,7 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract .createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName), true), new JetTestUtils.TestFileFactory() { @Override public JetFile create(String fileName, String text) { - return JetPsiFactory.createFile(project, fileName, text); + return JetPsiFactory.createFile(getProject(), fileName, text); } }); @@ -64,21 +66,15 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract doTestForGivenFiles(transform, includeMembersOfObject, files, filterJetNamespace, serializeResultsTo); } - protected void doTestForGivenFiles(Function, Pair> transform, + protected void doTestForGivenFiles( + Function, Pair> transform, boolean includeMembersOfObject, List files, Predicate filterJetNamespace, - File serializeResultsTo) { - ModuleDescriptor module = new ModuleDescriptor(Name.special("")); - InjectorForTopDownAnalyzer injector = createInjectorForTDA(module); - - InjectorForTopDownAnalyzer tdaInjectorForLazy = getEagerInjectorForTopDownAnalyzer(); - - ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); - ResolveSession - session = new ResolveSession(project, lazyModule, tdaInjectorForLazy.getModuleConfiguration(), new FileBasedDeclarationProviderFactory(files)); - - injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); + File serializeResultsTo + ) { + ModuleDescriptor module = resolveEagerly(files, ConfigurationKind.JDK_ONLY); + ModuleDescriptor lazyModule = resolveLazily(files, ConfigurationKind.JDK_ONLY); Pair namespacesToCompare = transform.fun(Pair.create(module, lazyModule)); @@ -86,6 +82,23 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract includeMembersOfObject, filterJetNamespace, serializeResultsTo); } + private ModuleDescriptor resolveLazily(List files, ConfigurationKind configurationKind) { + ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); + JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind); + ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer(environment).getModuleConfiguration(); + ResolveSession + session = new ResolveSession(getProject(), lazyModule, moduleConfiguration, new FileBasedDeclarationProviderFactory(files)); + return lazyModule; + } + + protected ModuleDescriptor resolveEagerly(List files, ConfigurationKind configurationKind) { + ModuleDescriptor module = new ModuleDescriptor(Name.special("")); + JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind); + InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment); + injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); + return module; + } + protected void doTest(String testFileName) throws Exception { doTest(testFileName, new Function, Pair>() { @Override @@ -105,8 +118,11 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract public Pair fun(Pair pair) { ModuleDescriptor expectedModule = pair.first; ModuleDescriptor actualModule = pair.second; - NamespaceDescriptor actual = theOnlySubPackage(actualModule.getRootNamespace()); - NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(actual.getName()); + Name test = Name.identifier("test"); + NamespaceDescriptor actual = actualModule.getRootNamespace().getMemberScope().getNamespace(test); + NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(test); + //NamespaceDescriptor actual = theOnlySubPackage(actualModule.getRootNamespace()); + //NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(actual.getName()); return Pair.create(expected, actual); } }, includeMembersOfObject); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java index 3356f1cc723..4b40aafb337 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java @@ -21,8 +21,9 @@ import com.intellij.openapi.Disposable; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Disposer; import com.intellij.psi.PsiFile; -import org.jetbrains.jet.CompileCompilerDependenciesTest; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; @@ -42,16 +43,30 @@ import java.util.Collections; * @author abreslav */ public abstract class AbstractLazyResolveTest { + private final Disposable rootDisposable = new Disposable() { @Override public void dispose() { } }; - protected final JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(rootDisposable, - CompileCompilerDependenciesTest.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, true) - ); - protected final Project project = jetCoreEnvironment.getProject(); + public class JetCoreEnvironmentWithDisposable { + + public final JetCoreEnvironment jetCoreEnvironment; + public final Project project; + + public JetCoreEnvironmentWithDisposable(@NotNull ConfigurationKind configurationKind) { + this.jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(rootDisposable, configurationKind); + this.project = jetCoreEnvironment.getProject(); + } + + } + + protected final JetCoreEnvironmentWithDisposable regularEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.ALL); + + protected Project getProject() { + return regularEnvironment.project; + } @BeforeClass public static void setUp() throws Exception { @@ -63,20 +78,20 @@ public abstract class AbstractLazyResolveTest { Disposer.dispose(rootDisposable); } - protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer() { + protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironmentWithDisposable environment) { ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("")); - InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy); + InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment); // This line is required fro the 'jet' namespace to be filled in with functions tdaInjectorForLazy.getTopDownAnalyzer().analyzeFiles( - Collections.singletonList(JetPsiFactory.createFile(project, "")), Collections.emptyList()); + Collections.singletonList(JetPsiFactory.createFile(getProject(), "")), Collections.emptyList()); return tdaInjectorForLazy; } - protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module) { + protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironmentWithDisposable environment) { TopDownAnalysisParameters params = new TopDownAnalysisParameters( Predicates.alwaysTrue(), false, false, Collections.emptyList()); - return new InjectorForTopDownAnalyzerForJvm(project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL); + return new InjectorForTopDownAnalyzerForJvm(environment.project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java index bff5aa8e036..1d366b4c399 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java @@ -62,7 +62,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest { ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); ResolveSession session = new ResolveSession( - project, + getProject(), lazyModule, new SpecialModuleConfiguration(), new FileBasedDeclarationProviderFactory(files), @@ -88,7 +88,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest { private void addJetFilesFromDir(List files, File jetDir) throws IOException { for (File file : jetDir.listFiles()) { if (FileUtil.getExtension(file.getName()).equals("jet")) { - files.add(JetPsiFactory.createFile(project, file.getName(), FileUtil.loadFile(file, true))); + files.add(JetPsiFactory.createFile(getProject(), file.getName(), FileUtil.loadFile(file, true))); } } } @@ -97,7 +97,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest { @Override public void addDefaultImports(@NotNull Collection directives) { for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport)); + directives.add(JetPsiFactory.createImportDirective(getProject(), defaultJetImport)); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java index bdfc8e633a7..ef0e226f267 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java @@ -34,7 +34,7 @@ import java.util.Set; public class LazyResolveDescriptorRendererTestGenerated { public static class Renderer extends AbstractLazyResolveDescriptorRendererTest { @Test - public void allTestsPresentInRenderer() throws Exception { + public void testAllFilesPresentInRenderer() throws Exception { allTestsPresent(Renderer.class, new File("compiler/testData/renderer"), true); } @@ -103,7 +103,7 @@ public class LazyResolveDescriptorRendererTestGenerated { public static class DescriptorRenderer extends AbstractLazyResolveDescriptorRendererTest { @Test - public void allTestsPresentInDescriptorRenderer() throws Exception { + public void testAllFilesPresentInDescriptorRenderer() throws Exception { allTestsPresent(DescriptorRenderer.class, new File("compiler/testData/lazyResolve/descriptorRenderer"), true); } 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 4645e1f72bb..2b7c30a467f 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -30,12 +30,12 @@ import java.util.Set; @Suite.SuiteClasses({ LazyResolveNamespaceComparingTestGenerated.ReadKotlinBinaryClass.class, LazyResolveNamespaceComparingTestGenerated.ReadJavaBinaryClass.class, - LazyResolveNamespaceComparingTestGenerated.LazyResolve.class + LazyResolveNamespaceComparingTestGenerated.NamespaceComparator.class }) public class LazyResolveNamespaceComparingTestGenerated { public static class ReadKotlinBinaryClass extends AbstractLazyResolveNamespaceComparingTest { @Test - public void allTestsPresentInReadKotlinBinaryClass() throws Exception { + public void testAllFilesPresentInReadKotlinBinaryClass() throws Exception { allTestsPresent(ReadKotlinBinaryClass.class, new File("compiler/testData/readKotlinBinaryClass"), true); } @@ -769,7 +769,7 @@ public class LazyResolveNamespaceComparingTestGenerated { public static class ReadJavaBinaryClass extends AbstractLazyResolveNamespaceComparingTest { @Test - public void allTestsPresentInReadJavaBinaryClass() throws Exception { + public void testAllFilesPresentInReadJavaBinaryClass() throws Exception { allTestsPresent(ReadJavaBinaryClass.class, new File("compiler/testData/readJavaBinaryClass"), true); } @@ -1048,6 +1048,11 @@ public class LazyResolveNamespaceComparingTestGenerated { doTestSinglePackage("compiler/testData/readJavaBinaryClass/MethosWithPRefTP.kt"); } + @Test + public void testModalityOfFakeOverrides() throws Exception { + doTestSinglePackage("compiler/testData/readJavaBinaryClass/modality/ModalityOfFakeOverrides.kt"); + } + @Test public void testMyException() throws Exception { doTestSinglePackage("compiler/testData/readJavaBinaryClass/MyException.kt"); @@ -1111,15 +1116,10 @@ public class LazyResolveNamespaceComparingTestGenerated { } } - public static class LazyResolve extends AbstractLazyResolveNamespaceComparingTest { + public static class NamespaceComparator extends AbstractLazyResolveNamespaceComparingTest { @Test - public void allTestsPresentInLazyResolve() throws Exception { - allTestsPresent(LazyResolve.class, new File("compiler/testData/lazyResolve"), true); - } - - @Test - public void testClassObject() throws Exception { - doTest("compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt"); + public void testAllFilesPresentInNamespaceComparator() throws Exception { + allTestsPresent(NamespaceComparator.class, new File("compiler/testData/lazyResolve/namespaceComparator"), true); } @Test diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerator.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerator.java index d63a75e6eda..4cd45b0d053 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerator.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerator.java @@ -75,7 +75,7 @@ public class LazyResolveTestGenerator { true, TestGenerator.filterFilesByExtension(TEST_DATA_FILE_EXTENSION), "doTestSinglePackage"), - new TestDataSource(new File("compiler/testData/lazyResolve"), + new TestDataSource(new File("compiler/testData/lazyResolve/namespaceComparator"), true, TestGenerator.filterFilesByExtension(TEST_DATA_FILE_EXTENSION), "doTest")