From 20860cb40bd23c1a2a17de73acf216ef0d23587c Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 10 Jul 2012 21:10:39 +0400 Subject: [PATCH] New resolveLazily(): accounts for Java interop --- ...ractLazyResolveDescriptorRendererTest.java | 2 +- ...ractLazyResolveNamespaceComparingTest.java | 21 +++-- .../resolve/lazy/AbstractLazyResolveTest.java | 81 ++++++++++++++++--- ...esolveNamespaceComparingTestGenerated.java | 5 ++ 4 files changed, 88 insertions(+), 21 deletions(-) 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 b9625c270b5..5a704b8725d 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -47,7 +47,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends Abstract protected void doTest(@NotNull String testFile) throws IOException { - InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(getRegularEnvironment()); + InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(getRegularEnvironment().jetCoreEnvironment); JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true)); Collection files = Lists.newArrayList(psiFile); 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 9960fe832a8..f7e398559fb 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java @@ -23,7 +23,6 @@ import com.intellij.util.Function; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; 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; @@ -74,8 +73,8 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract Predicate filterJetNamespace, File serializeResultsTo ) { - ModuleDescriptor module = resolveEagerly(files, ConfigurationKind.JDK_ONLY); - ModuleDescriptor lazyModule = resolveLazily(files, ConfigurationKind.JDK_ONLY); + ModuleDescriptor module = resolveEagerly(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment); + ModuleDescriptor lazyModule = resolveLazily(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment); Pair namespacesToCompare = transform.fun(Pair.create(module, lazyModule)); @@ -83,14 +82,14 @@ 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; - } + //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 void doTest(String testFileName) throws Exception { doTest(testFileName, new Function, Pair>() { 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 125506d7d28..73ef603b491 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java @@ -16,21 +16,34 @@ package org.jetbrains.jet.lang.resolve.lazy; +import com.google.common.base.Predicate; import com.google.common.base.Predicates; +import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; -import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.KotlinTestWithDefaultEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; +import org.jetbrains.jet.lang.DefaultModuleConfiguration; +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; +import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.psi.JetPsiFactory; -import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; +import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.JavaPackageScope; +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.WritableScope; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; +import java.util.Collection; import java.util.Collections; import java.util.List; @@ -39,7 +52,7 @@ import java.util.List; */ public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvironment { - protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironmentWithDisposable environment) { + protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironment environment) { ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("")); InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment); @@ -49,18 +62,68 @@ public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvir return tdaInjectorForLazy; } - protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironmentWithDisposable environment) { + protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironment environment) { TopDownAnalysisParameters params = new TopDownAnalysisParameters( Predicates.alwaysTrue(), false, false, Collections.emptyList()); - return new InjectorForTopDownAnalyzerForJvm(environment.project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL); + return new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL); } - protected ModuleDescriptor resolveEagerly(List files, ConfigurationKind configurationKind) { + protected ModuleDescriptor resolveEagerly(List files, JetCoreEnvironment environment) { 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 ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment) { + ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("")); + + final Project project = environment.getProject(); + InjectorForJavaDescriptorResolver injector = + new InjectorForJavaDescriptorResolver(project, new BindingTraceContext(), javaModule, BuiltinsScopeExtensionMode.ALL); + final PsiClassFinder psiClassFinder = injector.getPsiClassFinder(); + final JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); + + + final FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(files, new Predicate() { + @Override + public boolean apply(FqName fqName) { + return psiClassFinder.findPsiPackage(fqName) != null || new FqName("jet").equals(fqName); + } + }); + + //ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer().getModuleConfiguration(); + 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)); + } + } + + @Override + public void extendNamespaceScope( + @NotNull BindingTrace trace, + @NotNull NamespaceDescriptor namespaceDescriptor, + @NotNull WritableScope namespaceMemberScope + ) { + FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe(); + if (new FqName("jet").equals(fqName)) { + namespaceMemberScope.importScope(JetStandardLibrary.getInstance().getLibraryScope()); + } + if (psiClassFinder.findPsiPackage(fqName) != null) { + System.out.println(fqName); + JavaPackageScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(fqName, namespaceDescriptor); + namespaceMemberScope.importScope(javaPackageScope); + } + } + }; + + ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); + ResolveSession + session = new ResolveSession(project, lazyModule, moduleConfiguration, declarationProviderFactory); + return lazyModule; + } + } 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 87b06fc4aae..1a85ebd1f9c 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -1275,6 +1275,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTest("compiler/testData/lazyResolve/namespaceComparator/genericFunction.kt"); } + @TestMetadata("iterator.kt") + public void testIterator() throws Exception { + doTest("compiler/testData/lazyResolve/namespaceComparator/iterator.kt"); + } + @TestMetadata("packageLevelObject.kt") public void testPackageLevelObject() throws Exception { doTest("compiler/testData/lazyResolve/namespaceComparator/packageLevelObject.kt");