From 83bc8d4f213989b2e324eff18895ec0528ec1fb0 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 30 Jan 2013 21:03:08 +0400 Subject: [PATCH] Centralize and cache creating import directives --- .../di/InjectorForJavaDescriptorResolver.java | 1 - .../di/InjectorForJavaSemanticServices.java | 1 - .../di/InjectorForTopDownAnalyzerForJvm.java | 7 ++- .../resolve/java/AnalyzerFacadeForJVM.java | 16 +++--- .../resolve/java/JavaBridgeConfiguration.java | 32 +++++------- .../jet/analyzer/AnalyzeExhaust.java | 10 ++-- .../jet/di/InjectorForLazyResolve.java | 9 ++++ .../di/InjectorForTopDownAnalyzerBasic.java | 6 +++ .../jet/lang/DefaultModuleConfiguration.java | 27 ++++------ .../jet/lang/ModuleConfiguration.java | 10 ++-- .../jetbrains/jet/lang/psi/JetPsiBuilder.java | 50 +++++++++++++++++++ .../jet/lang/resolve/ImportsResolver.java | 33 ++++++++---- .../jet/lang/resolve/lazy/ScopeProvider.java | 6 ++- .../jet/lang/types/lang/KotlinBuiltIns.java | 15 ++---- .../resolve/lazy/LazyResolveTestUtil.java | 16 +++--- .../injectors/GenerateInjectors.java | 2 + .../libraries/JetSourceNavigationHelper.java | 2 +- .../di/InjectorForTopDownAnalyzerForJs.java | 6 +++ .../k2js/analyze/AnalyzerFacadeForJS.java | 6 +-- .../k2js/analyze/JsConfiguration.java | 25 +++------- 20 files changed, 172 insertions(+), 108 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index dc52473dd14..2bbd6d8cb39 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 85d4250efc5..74425a00572 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 053e075cbc9..5a1690d9a54 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 779a9fd77be..8a37dbdb52c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/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 directives) { - final Collection defaultImports = Lists.newArrayList(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS); - defaultImports.addAll(Arrays.asList(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS)); - - for (ImportPath defaultJetImport : defaultImports) { - directives.add(JetPsiFactory.createImportDirective(fileProject, defaultJetImport)); - } + public List getDefaultImports() { + LinkedHashSet imports = Sets.newLinkedHashSet(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS); + imports.addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS); + return Lists.newArrayList(imports); } @Override diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java index 6064b1de51c..3d183a0e7bf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java +++ b/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 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 directives) { - for (ImportPath importPath : DEFAULT_JAVA_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, importPath)); - } - delegateConfiguration.addDefaultImports(directives); + public List getDefaultImports() { + Set imports = Sets.newLinkedHashSet(DEFAULT_JAVA_IMPORTS); + imports.addAll(delegateConfiguration.getDefaultImports()); + + return Lists.newArrayList(imports); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java index 63ffd872eaf..3b66448d58b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java +++ b/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 directives) { + public List getDefaultImports() { + return Collections.emptyList(); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 1e7945b5077..274b3b610de 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/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; + } + } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 35d0b537a9e..03fccadbc3e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java index 1fe95fe0e02..f7058742d4e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java +++ b/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[] { - new ImportPath("kotlin.*"), new ImportPath("kotlin.io.*"), new ImportPath("jet.*"), }; + public static final List DEFAULT_JET_IMPORTS = ImmutableList.of( + new ImportPath("kotlin.*"), + new ImportPath("kotlin.io.*"), + new ImportPath("jet.*")); - private final Project project; - - public static DefaultModuleConfiguration createStandardConfiguration(Project project) { - return new DefaultModuleConfiguration(project); + public static DefaultModuleConfiguration createStandardConfiguration() { + return new DefaultModuleConfiguration(); } - private DefaultModuleConfiguration(@NotNull Project project) { - this.project = project; + private DefaultModuleConfiguration() { } @Override - public void addDefaultImports(@NotNull Collection directives) { - for (ImportPath defaultJetImport : DEFAULT_JET_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport)); - } + public List getDefaultImports() { + return DEFAULT_JET_IMPORTS; } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java index d12bc3c89d0..98ab5190355 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java +++ b/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 directives) { + public List getDefaultImports() { + return Collections.emptyList(); } @Override @@ -46,7 +48,7 @@ public interface ModuleConfiguration { } }; - void addDefaultImports(@NotNull Collection directives); + List 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 diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiBuilder.java new file mode 100644 index 00000000000..3b189edc4c0 --- /dev/null +++ b/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 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; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 874519249a4..84b4f3d03ce 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/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.USELESS_HIDDEN_IMPORT; -import static org.jetbrains.jet.lang.diagnostics.Errors.USELESS_SIMPLE_IMPORT; +import static org.jetbrains.jet.lang.diagnostics.Errors.*; 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 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 resolvedDirectives = Maps.newHashMap(); - Collection defaultImportDirectives = Lists.newArrayList(); - configuration.addDefaultImports(defaultImportDirectives); - for (JetImportDirective defaultImportDirective : defaultImportDirectives) { + + for (ImportPath defaultImportPath : configuration.getDefaultImports()) { 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 resolvedDirectives = Maps.newHashMap(); + for (JetImportDirective importDirective : importDirectives) { Collection descriptors = qualifiedExpressionResolver.processImportReference(importDirective, rootScope, namespaceScope, delayedImporter, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index 2229c530919..8e5160902e5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 0ba6278510f..fb4ea1ae0f6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/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() { @Override @@ -263,17 +263,12 @@ public class KotlinBuiltIns { private static class SpecialModuleConfiguration implements ModuleConfiguration { - private final Project project; - - private SpecialModuleConfiguration(@NotNull Project project) { - this.project = project; + private SpecialModuleConfiguration() { } @Override - public void addDefaultImports(@NotNull Collection directives) { - for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport)); - } + public List getDefaultImports() { + return DefaultModuleConfiguration.DEFAULT_JET_IMPORTS; } @Override diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index 7e8058fda38..f4d90395eaa 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/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 directives) { - directives.add(JetPsiFactory.createImportDirective(project, new ImportPath("java.lang.*"))); - for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) { - directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport)); - } + public List getDefaultImports() { + List imports = Lists.newArrayList(new ImportPath("java.lang.*")); + imports.addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS); + return imports; } @Override diff --git a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index 88f51bc9adc..d9e69574a56 100644 --- a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/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); } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index eaf405bebab..1168c71498c 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -211,7 +211,7 @@ public class JetSourceNavigationHelper { project, storageManager, new ModuleDescriptor(Name.special("")), - DefaultModuleConfiguration.createStandardConfiguration(project), + DefaultModuleConfiguration.createStandardConfiguration(), providerFactory); for (JetNamedDeclaration candidate : candidates) { diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 0b0cca2f060..a8a208476bb 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/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); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index 7612c4ec77e..f53c7da0466 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/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 allFiles = libraryBindingContext != null ? files : @@ -144,6 +144,6 @@ public final class AnalyzerFacadeForJS { FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( storageManager, Config.withJsLibAdded(files, config), Predicates.alwaysFalse()); ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); - return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(config.getProject(), null), declarationProviderFactory); + return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(null), declarationProviderFactory); } } diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java b/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java index 788e3d1b009..8f3cfd363b5 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java +++ b/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 DEFAULT_IMPORT_PATHS = Arrays.asList( + public static final List 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 directives) { - for (ImportPath path : DEFAULT_IMPORT_PATHS) { - directives.add(JetPsiFactory.createImportDirective(project, path)); - } + public List 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