New resolveLazily(): accounts for Java interop

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<JetFile> files = Lists.newArrayList(psiFile);

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<NamespaceDescriptor> filterJetNamespace,
             File serializeResultsTo
     ) {
-        ModuleDescriptor module = resolveEagerly(files, ConfigurationKind.JDK_ONLY);
+        ModuleDescriptor module = resolveEagerly(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment);
-        ModuleDescriptor lazyModule = resolveLazily(files, ConfigurationKind.JDK_ONLY);
+        ModuleDescriptor lazyModule = resolveLazily(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment);
 
         Pair<NamespaceDescriptor, NamespaceDescriptor> namespacesToCompare = transform.fun(Pair.create(module, lazyModule));
 
@@ -83,14 +82,14 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
                                               includeMembersOfObject, filterJetNamespace, serializeResultsTo);
     }
 
-    private ModuleDescriptor resolveLazily(List<JetFile> files, ConfigurationKind configurationKind) {
+    //private ModuleDescriptor resolveLazily(List<JetFile> files, ConfigurationKind configurationKind) {
-        ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
+    //    ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
-        JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
+    //    JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
-        ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer(environment).getModuleConfiguration();
+    //    ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer(environment).getModuleConfiguration();
-        ResolveSession
+    //    ResolveSession
-                session = new ResolveSession(getProject(), lazyModule, moduleConfiguration, new FileBasedDeclarationProviderFactory(files));
+    //            session = new ResolveSession(getProject(), lazyModule, moduleConfiguration, new FileBasedDeclarationProviderFactory(files));
-        return lazyModule;
+    //    return lazyModule;
-    }
+    //}
 
     protected void doTest(String testFileName) throws Exception {
         doTest(testFileName, new Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>>() {

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.*;
-import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+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("<eager module for lazy>"));
 
         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.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>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<JetFile> files, ConfigurationKind configurationKind) {
+    protected ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
         ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
-        JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
         InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
         injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
         return module;
     }
 
+    protected ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment) {
+        ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("<lazy module>"));
+
+        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<FqName>() {
+            @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<JetImportDirective> 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("<lazy module>"));
+        ResolveSession
+                session = new ResolveSession(project, lazyModule, moduleConfiguration, declarationProviderFactory);
+        return lazyModule;
+    }
+
 }

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");