diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java index e21ac04214f..c7501b85c78 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacade.java @@ -12,6 +12,8 @@ import com.intellij.psi.util.CachedValuesManager; import com.intellij.psi.util.PsiModificationTracker; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.JetSemanticServices; +import org.jetbrains.jet.lang.StandardConfiguration; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.diagnostics.Errors; @@ -80,12 +82,15 @@ public class AnalyzerFacade { public static BindingContext analyzeNamespacesWithJavaIntegration(Project project, Collection declarations, Predicate filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); - return AnalyzingUtils.getInstance().analyzeNamespacesWithGivenTrace( + JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project); + return AnalyzingUtils.analyzeNamespacesWithGivenTrace( project, - JavaBridgeConfiguration.createJavaBridgeConfiguration(project, bindingTraceContext), + JavaBridgeConfiguration.createJavaBridgeConfiguration(project, bindingTraceContext, StandardConfiguration.createStandardConfiguration(project, semanticServices)), declarations, filesToAnalyzeCompletely, - flowDataTraceFactory, bindingTraceContext); + flowDataTraceFactory, + bindingTraceContext, + semanticServices); } public static BindingContext shallowAnalyzeFiles(Collection files) { 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 a160b707229..d2dc2bd88fa 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 @@ -14,24 +14,28 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; */ public class JavaBridgeConfiguration implements Configuration { - public static Configuration createJavaBridgeConfiguration(@NotNull Project project, @NotNull BindingTrace trace) { - return new JavaBridgeConfiguration(project, trace); + public static Configuration createJavaBridgeConfiguration(@NotNull Project project, @NotNull BindingTrace trace, Configuration delegateConfiguration) { + return new JavaBridgeConfiguration(project, trace, delegateConfiguration); } private final JavaSemanticServices javaSemanticServices; + private final Configuration delegateConfiguration; - private JavaBridgeConfiguration(Project project, BindingTrace trace) { + private JavaBridgeConfiguration(Project project, BindingTrace trace, Configuration delegateConfiguration) { this.javaSemanticServices = new JavaSemanticServices(project, JetSemanticServices.createSemanticServices(project), trace); + this.delegateConfiguration = delegateConfiguration; } @Override - public void addDefaultImports(BindingTrace trace, WritableScope rootScope) { + public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope) { rootScope.importScope(new JavaPackageScope("", null, javaSemanticServices)); rootScope.importScope(new JavaPackageScope("java.lang", null, javaSemanticServices)); + delegateConfiguration.addDefaultImports(trace, rootScope); } @Override - public void extendNamespaceScope(BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { + public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { namespaceMemberScope.importScope(new JavaPackageScope(DescriptorUtils.getFQName(namespaceDescriptor), namespaceDescriptor, javaSemanticServices)); + delegateConfiguration.extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java b/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java index e376a6ebaf6..60633836bfc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java @@ -11,19 +11,19 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; public interface Configuration { Configuration EMPTY = new Configuration() { @Override - public void addDefaultImports(BindingTrace trace, WritableScope rootScope) { + public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope) { } @Override - public void extendNamespaceScope(BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { + public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { } }; - void addDefaultImports(BindingTrace trace, WritableScope rootScope); + void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope); /** * * This method is called every time a namespace descriptor is created. Use it to add extra descriptors to the namespace, e.g. merge a Java package with a Kotlin one */ - void extendNamespaceScope(BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope); + void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java new file mode 100644 index 00000000000..e4ddbd8f033 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java @@ -0,0 +1,42 @@ +package org.jetbrains.jet.lang; + +import com.intellij.openapi.project.Project; +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.ImportsResolver; +import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; + +/** + * @author svtk + */ +public class StandardConfiguration implements Configuration { + private Project project; + private JetSemanticServices services; + + public static StandardConfiguration createStandardConfiguration(Project project, JetSemanticServices services) { + return new StandardConfiguration(services, project); + } + + private StandardConfiguration(JetSemanticServices services, Project project) { + this.services = services; + this.project = project; + } + + @Override + public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope) { + TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); + JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, "std.*"); + if (ImportsResolver.importNamespace(importDirective, rootScope, temporaryTrace, services)) { + temporaryTrace.commit(); + } + } + + @Override + public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { + } + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java index 7e5d791edd3..911a7d778fb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java @@ -31,12 +31,6 @@ import java.util.Map; */ public class AnalyzingUtils { - private static final AnalyzingUtils INSTANCE = new AnalyzingUtils(); - - public static AnalyzingUtils getInstance() { - return INSTANCE; - } - public static void checkForSyntacticErrors(@NotNull PsiElement root) { root.acceptChildren(new PsiElementVisitor() { @Override @@ -75,19 +69,25 @@ public class AnalyzingUtils { // -------------------------------------------------------------------------------------------------------------------------- - public BindingContext analyzeNamespaces( + public static BindingContext analyzeNamespaces( @NotNull Project project, @NotNull Configuration configuration, @NotNull Collection declarations, @NotNull Predicate filesToAnalyzeCompletely, - @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) { + @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory, + @NotNull JetSemanticServices semanticServices) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); - return analyzeNamespacesWithGivenTrace(project, configuration, declarations, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext); + return analyzeNamespacesWithGivenTrace(project, configuration, declarations, filesToAnalyzeCompletely, flowDataTraceFactory, bindingTraceContext, semanticServices); } - public BindingContext analyzeNamespacesWithGivenTrace(Project project, Configuration configuration, Collection declarations, Predicate filesToAnalyzeCompletely, JetControlFlowDataTraceFactory flowDataTraceFactory, BindingTraceContext bindingTraceContext) { - JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project); - + public static BindingContext analyzeNamespacesWithGivenTrace( + @NotNull Project project, + @NotNull Configuration configuration, + @NotNull Collection declarations, + @NotNull Predicate filesToAnalyzeCompletely, + @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory, + @NotNull BindingTraceContext bindingTraceContext, + @NotNull JetSemanticServices semanticServices) { JetScope libraryScope = semanticServices.getStandardLibrary().getLibraryScope(); ModuleDescriptor owner = new ModuleDescriptor(""); 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 a96ce5d3f4a..a4c30b5fb32 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -1,6 +1,7 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.*; @@ -40,14 +41,7 @@ public class ImportsResolver { continue; } if (importDirective.isAllUnder()) { - JetExpression importedReference = importDirective.getImportedReference(); - if (importedReference != null) { - ExpressionTypingServices typeInferrerServices = context.getSemanticServices().getTypeInferrerServices(context.getTrace()); - JetType type = typeInferrerServices.getTypeWithNamespaces(namespaceScope, importedReference); - if (type != null) { - namespaceScope.importScope(type.getMemberScope()); - } - } + importNamespace(importDirective, namespaceScope, context.getTrace(), context.getSemanticServices()); } else { ClassifierDescriptor classifierDescriptor = null; @@ -105,4 +99,17 @@ public class ImportsResolver { } } } + + public static boolean importNamespace(JetImportDirective importDirective, WritableScope namespaceScope, @NotNull BindingTrace trace, @NotNull JetSemanticServices services) { + JetExpression importedReference = importDirective.getImportedReference(); + if (importedReference != null) { + ExpressionTypingServices typeInferrerServices = services.getTypeInferrerServices(trace); + JetType type = typeInferrerServices.getTypeWithNamespaces(namespaceScope, importedReference); + if (type != null) { + namespaceScope.importScope(type.getMemberScope()); + return true; + } + } + return false; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 7760ae9f44e..a47e6a7e8ae 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -91,7 +91,9 @@ public class TopDownAnalyzer { public static void processStandardLibraryNamespace( @NotNull JetSemanticServices semanticServices, @NotNull BindingTrace trace, - @NotNull WritableScope outerScope, @NotNull NamespaceDescriptorImpl standardLibraryNamespace, @NotNull JetNamespace namespace) { + @NotNull WritableScope outerScope, + @NotNull NamespaceDescriptorImpl standardLibraryNamespace, + @NotNull JetNamespace namespace) { TopDownAnalysisContext context = new TopDownAnalysisContext(semanticServices, trace, Predicates.alwaysTrue(), Configuration.EMPTY, false); context.getNamespaceScopes().put(namespace, standardLibraryNamespace.getMemberScope()); context.getNamespaceDescriptors().put(namespace, standardLibraryNamespace); diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java index e661113e310..464e7e6de8b 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java @@ -10,6 +10,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.lang.Configuration; +import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.psi.JetDeclaration; @@ -94,7 +95,7 @@ public class JetDiagnosticsTest extends JetLiteFixture { bindingContext = AnalyzerFacade.analyzeNamespacesWithJavaIntegration(getProject(), namespaces, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY); } else { - bindingContext = AnalyzingUtils.getInstance().analyzeNamespaces(getProject(), Configuration.EMPTY, namespaces, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY); + bindingContext = AnalyzingUtils.analyzeNamespaces(getProject(), Configuration.EMPTY, namespaces, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, JetSemanticServices.createSemanticServices(getProject())); } StringBuilder actualText = new StringBuilder();