Centralize and cache creating import directives

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

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<JetFile> allFiles = libraryBindingContext != null ?
                                            files :
@@ -144,6 +144,6 @@ public final class AnalyzerFacadeForJS {
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
                 storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
         ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
-        return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(config.getProject(), null), declarationProviderFactory);
+        return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(null), declarationProviderFactory);
     }
 }

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<ImportPath> DEFAULT_IMPORT_PATHS = Arrays.asList(
+    public static final List<ImportPath> 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<JetImportDirective> directives) {
-        for (ImportPath path : DEFAULT_IMPORT_PATHS) {
-            directives.add(JetPsiFactory.createImportDirective(project, path));
-        }
+    public List<ImportPath> 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