Centralize and cache creating import directives

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

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

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

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<JetImportDirective> directives) {
+            public List<ImportPath> getDefaultImports() {
-                final Collection<ImportPath> defaultImports = Lists.newArrayList(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS);
+                LinkedHashSet<ImportPath> imports = Sets.newLinkedHashSet(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS);
-                defaultImports.addAll(Arrays.asList(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS));
+                imports.addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
-
+                return Lists.newArrayList(imports);
-                for (ImportPath defaultJetImport : defaultImports) {
-                    directives.add(JetPsiFactory.createImportDirective(fileProject, defaultJetImport));
-                }
             }
 
             @Override

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<ImportPath> 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<JetImportDirective> directives) {
+    public List<ImportPath> getDefaultImports() {
-        for (ImportPath importPath : DEFAULT_JAVA_IMPORTS) {
+        Set<ImportPath> imports = Sets.newLinkedHashSet(DEFAULT_JAVA_IMPORTS);
-            directives.add(JetPsiFactory.createImportDirective(project, importPath));
+        imports.addAll(delegateConfiguration.getDefaultImports());
-        }
+
-        delegateConfiguration.addDefaultImports(directives);
+        return Lists.newArrayList(imports);
     }
 
     @Override

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<JetImportDirective> directives) {
+        public List<ImportPath> getDefaultImports() {
+            return Collections.emptyList();
         }
 
         @Override

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;
+    }
+
 }

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

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[] {
+    public static final List<ImportPath> DEFAULT_JET_IMPORTS = ImmutableList.of(
-            new ImportPath("kotlin.*"), new ImportPath("kotlin.io.*"), new ImportPath("jet.*"), };
+            new ImportPath("kotlin.*"),
+            new ImportPath("kotlin.io.*"),
+            new ImportPath("jet.*"));
 
-    private final Project project;
+    public static DefaultModuleConfiguration createStandardConfiguration() {
-
+        return new DefaultModuleConfiguration();
-    public static DefaultModuleConfiguration createStandardConfiguration(Project project) {
-        return new DefaultModuleConfiguration(project);
     }
 
-    private DefaultModuleConfiguration(@NotNull Project project) {
+    private DefaultModuleConfiguration() {
-        this.project = project;
     }
 
     @Override
-    public void addDefaultImports(@NotNull Collection<JetImportDirective> directives) {
+    public List<ImportPath> getDefaultImports() {
-        for (ImportPath defaultJetImport : DEFAULT_JET_IMPORTS) {
+        return DEFAULT_JET_IMPORTS;
-            directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport));
-        }
     }
 
     @Override

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<JetImportDirective> directives) {
+        public List<ImportPath> getDefaultImports() {
+            return Collections.emptyList();
         }
 
         @Override
@@ -46,7 +48,7 @@ public interface ModuleConfiguration {
         }
     };
 
-    void addDefaultImports(@NotNull Collection<JetImportDirective> directives);
+    List<ImportPath> 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

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<ImportPath, JetImportDirective> 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;
+    }
+}

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.*;
-import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_HIDDEN_IMPORT;
-import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_SIMPLE_IMPORT;
 
 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<JetImportDirective> 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<JetImportDirective, DeclarationDescriptor> resolvedDirectives = Maps.newHashMap();
+
-        Collection<JetImportDirective> defaultImportDirectives = Lists.newArrayList();
+        for (ImportPath defaultImportPath : configuration.getDefaultImports()) {
-        configuration.addDefaultImports(defaultImportDirectives);
-        for (JetImportDirective defaultImportDirective : defaultImportDirectives) {
             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<JetImportDirective, DeclarationDescriptor> resolvedDirectives = Maps.newHashMap();
+
         for (JetImportDirective importDirective : importDirectives) {
             Collection<? extends DeclarationDescriptor> descriptors =
                 qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter,

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

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<FqName, Name>() {
                     @Override
@@ -263,17 +263,12 @@ public class KotlinBuiltIns {
 
     private static class SpecialModuleConfiguration implements ModuleConfiguration {
 
-        private final Project project;
+        private SpecialModuleConfiguration() {
-
-        private SpecialModuleConfiguration(@NotNull Project project) {
-            this.project = project;
         }
 
         @Override
-        public void addDefaultImports(@NotNull Collection<JetImportDirective> directives) {
+        public List<ImportPath> getDefaultImports() {
-            for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) {
+            return DefaultModuleConfiguration.DEFAULT_JET_IMPORTS;
-                directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport));
-            }
         }
 
         @Override

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<JetImportDirective> directives) {
+            public List<ImportPath> getDefaultImports() {
-                directives.add(JetPsiFactory.createImportDirective(project, new ImportPath("java.lang.*")));
+                List<ImportPath> imports = Lists.newArrayList(new ImportPath("java.lang.*"));
-                for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) {
+                imports.addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS);
-                    directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport));
+                return imports;
-                }
             }
 
             @Override

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

idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -211,7 +211,7 @@ public class JetSourceNavigationHelper {
                 project,
                 storageManager,
                 new ModuleDescriptor(Name.special("<library module>")),
-                DefaultModuleConfiguration.createStandardConfiguration(project),
+                DefaultModuleConfiguration.createStandardConfiguration(),
                 providerFactory);
 
         for (JetNamedDeclaration candidate : candidates) {

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) {
+    JsConfiguration(@Nullable BindingContext preanalyzedContext) {
-        this.project = project;
         this.preanalyzedContext = preanalyzedContext;
     }
 
     @Override
-    public void addDefaultImports(@NotNull Collection<JetImportDirective> directives) {
+    public List<ImportPath> getDefaultImports() {
-        for (ImportPath path : DEFAULT_IMPORT_PATHS) {
+        return DEFAULT_IMPORT_PATHS;
-            directives.add(JetPsiFactory.createImportDirective(project, path));
-        }
     }
 
     @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