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 d2dc2bd88fa..77be1926646 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 @@ -7,6 +7,7 @@ import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.Importer; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; /** @@ -27,10 +28,10 @@ public class JavaBridgeConfiguration implements Configuration { } @Override - public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope) { + public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope, @NotNull Importer importer) { rootScope.importScope(new JavaPackageScope("", null, javaSemanticServices)); - rootScope.importScope(new JavaPackageScope("java.lang", null, javaSemanticServices)); - delegateConfiguration.addDefaultImports(trace, rootScope); + importer.addScopeImport(new JavaPackageScope("java.lang", null, javaSemanticServices)); + delegateConfiguration.addDefaultImports(trace, rootScope, importer); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java b/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java index 60633836bfc..d0946789b47 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/Configuration.java @@ -3,6 +3,7 @@ package org.jetbrains.jet.lang; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.Importer; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; /** @@ -11,7 +12,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; public interface Configuration { Configuration EMPTY = new Configuration() { @Override - public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope) { + public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope, @NotNull Importer importer) { } @Override @@ -19,7 +20,7 @@ public interface Configuration { } }; - void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope); + void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope, @NotNull Importer importer); /** * diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java index 9d553a51af0..6efca23099f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/StandardConfiguration.java @@ -3,9 +3,9 @@ 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.Importer; import org.jetbrains.jet.lang.resolve.ImportsResolver; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -24,9 +24,9 @@ public class StandardConfiguration implements Configuration { } @Override - public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope) { - JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, "std.*"); - new ImportsResolver.ImportResolver(trace, true).processImportReference(importDirective, rootScope); + public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope, @NotNull Importer importer) { + ImportsResolver.ImportResolver importResolver = new ImportsResolver.ImportResolver(trace, true); + importResolver.processImportReference(JetPsiFactory.createImportDirective(project, "std.*"), rootScope, importer); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index f3e3ca7f730..31e995218d6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -215,4 +215,12 @@ public class DescriptorUtils { } return null; } + + @Nullable + public static ClassDescriptor getObjectIfObjectOrClassObjectDescriptor(ClassDescriptor descriptor) { + if ((descriptor).getKind() == ClassKind.OBJECT) { + return descriptor; + } + return descriptor.getClassObjectDescriptor(); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java new file mode 100644 index 00000000000..50d44d21db8 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java @@ -0,0 +1,139 @@ +package org.jetbrains.jet.lang.resolve; + +import com.google.common.collect.Lists; +import com.intellij.openapi.util.Pair; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; +import java.util.List; + +/** + * @author svtk + */ +public interface Importer { + + void addAllUnderImport(@NotNull DeclarationDescriptor descriptor); + + void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull String aliasName); + + void addScopeImport(@NotNull JetScope scope); + + class StandardImporter implements Importer { + private final WritableScope namespaceScope; + private final boolean firstPhase; + + public StandardImporter(WritableScope namespaceScope, boolean firstPhase) { + this.namespaceScope = namespaceScope; + this.firstPhase = firstPhase; + } + + @Override + public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor) { + importAllUnderDeclaration(descriptor); + } + + @Override + public void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull String aliasName) { + importDeclarationAlias(descriptor, aliasName); + } + + @Override + public void addScopeImport(@NotNull JetScope scope) { + importScope(scope); + } + + protected void importScope(@NotNull JetScope scope) { + namespaceScope.importScope(scope); + } + + protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor) { + if (descriptor instanceof NamespaceDescriptor) { + namespaceScope.importScope(((NamespaceDescriptor) descriptor).getMemberScope()); + } + if (firstPhase) { + if (descriptor instanceof ClassDescriptor) { + ClassDescriptor objectDescriptor = DescriptorUtils.getObjectIfObjectOrClassObjectDescriptor((ClassDescriptor) descriptor); + if (objectDescriptor != null) { + Collection innerClassesAndObjects = objectDescriptor.getInnerClassesAndObjects(); + for (DeclarationDescriptor innerClassOrObject : innerClassesAndObjects) { + namespaceScope.importClassifierAlias(innerClassOrObject.getName(), (ClassifierDescriptor) innerClassOrObject); + } + } + } + return; + } + if (descriptor instanceof VariableDescriptor) { + JetType type = ((VariableDescriptor) descriptor).getOutType(); + namespaceScope.importScope(type.getMemberScope()); + } + else if (descriptor instanceof ClassDescriptor) { + JetType classObjectType = ((ClassDescriptor) descriptor).getClassObjectType(); + if (classObjectType != null) { + namespaceScope.importScope(classObjectType.getMemberScope()); + } + } + } + + protected void importDeclarationAlias(@NotNull DeclarationDescriptor descriptor, @NotNull String aliasName) { + if (descriptor instanceof ClassifierDescriptor) { + namespaceScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor); + } + else if (descriptor instanceof NamespaceDescriptor) { + namespaceScope.importNamespaceAlias(aliasName, (NamespaceDescriptor) descriptor); + } + else if (descriptor instanceof FunctionDescriptor) { + namespaceScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor); + } + else if (descriptor instanceof VariableDescriptor) { + namespaceScope.importVariableAlias(aliasName, (VariableDescriptor) descriptor); + } + } + + } + + class DelayedImporter extends StandardImporter { + private final List scopesToImport = Lists.newArrayList(); + private final List> imports = Lists.newArrayList(); + + public DelayedImporter(@NotNull WritableScope namespaceScope, boolean firstPhase) { + super(namespaceScope, firstPhase); + } + + @Override + public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor) { + imports.add(Pair.create(descriptor, null)); + } + + @Override + public void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull String aliasName) { + imports.add(Pair.create(descriptor, aliasName)); + } + + @Override + public void addScopeImport(@NotNull JetScope scope) { + scopesToImport.add(scope); + } + + public void processImports() { + for (JetScope scope : scopesToImport) { + importScope(scope); + } + for (Pair anImport : imports) { + DeclarationDescriptor descriptor = anImport.getFirst(); + String aliasName = anImport.getSecond(); + boolean allUnderImport = aliasName == null; + if (allUnderImport) { + importAllUnderDeclaration(descriptor); + } + else { + importDeclarationAlias(descriptor, aliasName); + } + } + } + } + +} 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 514e8d92968..ceb66cc9e2f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -4,6 +4,7 @@ import com.google.common.base.Predicate; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -39,19 +40,21 @@ public class ImportsResolver { ImportResolver importResolver = new ImportResolver(context.getTrace(), firstPhase); for (JetFile file : context.getNamespaceDescriptors().keySet()) { WritableScope namespaceScope = context.getNamespaceScopes().get(file); + Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope, firstPhase); if (!firstPhase) { namespaceScope.clearImports(); } - context.getConfiguration().addDefaultImports(context.getTrace(), namespaceScope); + context.getConfiguration().addDefaultImports(context.getTrace(), namespaceScope, delayedImporter); Map resolvedDirectives = Maps.newHashMap(); List importDirectives = file.getImportDirectives(); for (JetImportDirective importDirective : importDirectives) { - Collection descriptors = importResolver.processImportReference(importDirective, namespaceScope); + Collection descriptors = importResolver.processImportReference(importDirective, namespaceScope, delayedImporter); if (descriptors != null && descriptors.size() == 1) { resolvedDirectives.put(importDirective, descriptors.iterator().next()); } } + delayedImporter.processImports(); if (firstPhase) continue; for (JetImportDirective importDirective : importDirectives) { @@ -59,6 +62,7 @@ public class ImportsResolver { } } } + @Nullable private static JetSimpleNameExpression getLastReference(@NotNull JetExpression importedReference) { if (importedReference instanceof JetDotQualifiedExpression) { @@ -123,7 +127,7 @@ public class ImportsResolver { } @Nullable - public Collection processImportReference(@NotNull JetImportDirective importDirective, @NotNull WritableScope namespaceScope) { + public Collection processImportReference(@NotNull JetImportDirective importDirective, @NotNull JetScope scope, @NotNull Importer importer) { if (importDirective.isAbsoluteInRootNamespace()) { trace.report(UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")); // TODO return null; @@ -132,18 +136,18 @@ public class ImportsResolver { if (importedReference == null) return null; Collection descriptors; if (importedReference instanceof JetQualifiedExpression) { - descriptors = lookupDescriptorsForQualifiedExpression((JetQualifiedExpression) importedReference, namespaceScope); + descriptors = lookupDescriptorsForQualifiedExpression((JetQualifiedExpression) importedReference, scope); } else { assert importedReference instanceof JetSimpleNameExpression; - descriptors = lookupDescriptorsForSimpleNameReference((JetSimpleNameExpression) importedReference, namespaceScope, true); + descriptors = lookupDescriptorsForSimpleNameReference((JetSimpleNameExpression) importedReference, scope, true); } JetSimpleNameExpression referenceExpression = getLastReference(importedReference); if (importDirective.isAllUnder()) { if (referenceExpression == null || !canImportMembersFrom(descriptors, referenceExpression)) return null; for (DeclarationDescriptor descriptor : descriptors) { - importAllUnderDeclaration(descriptor, namespaceScope); + importer.addAllUnderImport(descriptor); } return null; } @@ -152,65 +156,11 @@ public class ImportsResolver { if (aliasName == null) return null; for (DeclarationDescriptor descriptor : descriptors) { - importDeclarationAlias(namespaceScope, aliasName, descriptor); + importer.addAliasImport(descriptor, aliasName); } return descriptors; } - private void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull WritableScope namespaceScope) { - if (firstPhase) { - if (descriptor instanceof NamespaceDescriptor) { - namespaceScope.importScope(((NamespaceDescriptor) descriptor).getMemberScope()); - } - if (descriptor instanceof ClassDescriptor) { - ClassDescriptor objectDescriptor = getObjectIfObjectOrClassObjectDescriptor((ClassDescriptor) descriptor); - if (objectDescriptor != null) { - Collection innerClassesAndObjects = objectDescriptor.getInnerClassesAndObjects(); - for (DeclarationDescriptor innerClassOrObject : innerClassesAndObjects) { - namespaceScope.importClassifierAlias(innerClassOrObject.getName(), (ClassifierDescriptor) innerClassOrObject); - } - } - } - return; - } - if (descriptor instanceof NamespaceDescriptor) { - namespaceScope.importScope(((NamespaceDescriptor) descriptor).getMemberScope()); - } - if (descriptor instanceof VariableDescriptor) { - JetType type = ((VariableDescriptor) descriptor).getOutType(); - namespaceScope.importScope(type.getMemberScope()); - } - else if (descriptor instanceof ClassDescriptor) { - JetType classObjectType = ((ClassDescriptor) descriptor).getClassObjectType(); - if (classObjectType != null) { - namespaceScope.importScope(classObjectType.getMemberScope()); - } - } - } - - @Nullable - private static ClassDescriptor getObjectIfObjectOrClassObjectDescriptor(ClassDescriptor descriptor) { - if ((descriptor).getKind() == ClassKind.OBJECT) { - return descriptor; - } - return descriptor.getClassObjectDescriptor(); - } - - private static void importDeclarationAlias(WritableScope namespaceScope, String aliasName, DeclarationDescriptor descriptor) { - if (descriptor instanceof ClassifierDescriptor) { - namespaceScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor); - } - else if (descriptor instanceof NamespaceDescriptor) { - namespaceScope.importNamespaceAlias(aliasName, (NamespaceDescriptor) descriptor); - } - else if (descriptor instanceof FunctionDescriptor) { - namespaceScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor); - } - else if (descriptor instanceof VariableDescriptor) { - namespaceScope.importVariableAlias(aliasName, (VariableDescriptor) descriptor); - } - } - @NotNull private Collection lookupDescriptorsForQualifiedExpression( @NotNull JetQualifiedExpression importedReference, @NotNull JetScope outerScope) { @@ -292,7 +242,7 @@ public class ImportsResolver { @NotNull private Collection lookupObjectMembers(@NotNull ClassDescriptor classDescriptor, @NotNull JetSimpleNameExpression memberReference) { if (firstPhase) { - ClassDescriptor objectDescriptor = getObjectIfObjectOrClassObjectDescriptor(classDescriptor); + ClassDescriptor objectDescriptor = DescriptorUtils.getObjectIfObjectOrClassObjectDescriptor(classDescriptor); if (objectDescriptor == null) return Collections.emptyList(); return getInnerClassesAndObjectsByName(objectDescriptor, memberReference); } diff --git a/compiler/testData/diagnostics/tests/ResolveToJava.jet b/compiler/testData/diagnostics/tests/ResolveToJava.jet index 4877ed5f61f..9c5a85b7f1e 100644 --- a/compiler/testData/diagnostics/tests/ResolveToJava.jet +++ b/compiler/testData/diagnostics/tests/ResolveToJava.jet @@ -2,7 +2,7 @@ // +JDK import java.* -import util.* +import java.util.* import utils.* import java.io.PrintStream diff --git a/compiler/testData/diagnostics/tests/regressions/DoubleDefine.jet b/compiler/testData/diagnostics/tests/regressions/DoubleDefine.jet index 74da10dc846..7d9592ea0ff 100644 --- a/compiler/testData/diagnostics/tests/regressions/DoubleDefine.jet +++ b/compiler/testData/diagnostics/tests/regressions/DoubleDefine.jet @@ -1,7 +1,6 @@ // +JDK -import java.* -import util.* +import java.util.* import java.io.* diff --git a/compiler/testData/diagnostics/tests/scopes/kt1080.jet b/compiler/testData/diagnostics/tests/scopes/kt1080.jet new file mode 100644 index 00000000000..d8f1b035942 --- /dev/null +++ b/compiler/testData/diagnostics/tests/scopes/kt1080.jet @@ -0,0 +1,16 @@ +//FILE:a.kt +//+JDK +//KT-1080 Don't use previously imported packages while resolving import references + +package kt1080 + +import reflect.Constructor + +import b.* +import d +import b.d + + +//FILE:b.kt + +package b.d \ No newline at end of file diff --git a/compiler/testData/resolve/ResolveOfInfixExpressions.jet b/compiler/testData/resolve/ResolveOfInfixExpressions.jet index de55e5a7ace..d66c8a7eee0 100644 --- a/compiler/testData/resolve/ResolveOfInfixExpressions.jet +++ b/compiler/testData/resolve/ResolveOfInfixExpressions.jet @@ -1,5 +1,5 @@ import java.* -import util.* +import java.util.* fun f_plus(): Int { var x: Int = 1 diff --git a/compiler/testData/resolve/ResolveToJava.jet b/compiler/testData/resolve/ResolveToJava.jet index ba345360b22..807f1d4bc0b 100644 --- a/compiler/testData/resolve/ResolveToJava.jet +++ b/compiler/testData/resolve/ResolveToJava.jet @@ -1,5 +1,5 @@ import `java::java`java.* -import `java::java.util`util.* +import java.`java::java.util`util.* fun foo(~a~a : `std::Array`Array<`std::Int`Int>) : `java::java.util.List`List { `a`a.`std::Array.get(Int)`get(1) diff --git a/compiler/testData/resolve/ResolveToJava2.jet b/compiler/testData/resolve/ResolveToJava2.jet index 9312e7870bb..4d737199b51 100644 --- a/compiler/testData/resolve/ResolveToJava2.jet +++ b/compiler/testData/resolve/ResolveToJava2.jet @@ -1,5 +1,5 @@ import `java::java`java.* -import `java::java.util`util.* +import java.`java::java.util`util.* ~c~fun c(~x~x : java.lang.`java::java.lang.Number`Number) { `x`x.`java::java.lang.Number.intValue()`intValue() diff --git a/compiler/testData/resolve/ResolveToJava3.jet b/compiler/testData/resolve/ResolveToJava3.jet index 8995c064f57..105bd77bca1 100644 --- a/compiler/testData/resolve/ResolveToJava3.jet +++ b/compiler/testData/resolve/ResolveToJava3.jet @@ -1,5 +1,5 @@ import `java::java`java.* -import `java::java.util`util.* +import java.`java::java.util`util.* class B : `java::java.lang.Object`Object { fun bar(~o~o : `java::java.lang.Object`Object) { diff --git a/compiler/testData/resolve/ResolveToJavaTypeTransform.jet b/compiler/testData/resolve/ResolveToJavaTypeTransform.jet index 14e82bedff9..e51f899bdaa 100644 --- a/compiler/testData/resolve/ResolveToJavaTypeTransform.jet +++ b/compiler/testData/resolve/ResolveToJavaTypeTransform.jet @@ -1,5 +1,5 @@ import `java::java`java.* -import `java::java.util`util.* +import java.`java::java.util`util.* fun typeTransform() { Integer.getInteger("", 239)`:std::Int` diff --git a/idea/testData/checker/ResolveToJava.jet b/idea/testData/checker/ResolveToJava.jet index 8386e48375d..3f880191b70 100644 --- a/idea/testData/checker/ResolveToJava.jet +++ b/idea/testData/checker/ResolveToJava.jet @@ -1,5 +1,5 @@ import java.* -import util.* +import java.util.* import utils.* import java.io.PrintStream diff --git a/idea/testData/checker/regression/DoubleDefine.jet b/idea/testData/checker/regression/DoubleDefine.jet index 09e2f188993..19270d04ccb 100644 --- a/idea/testData/checker/regression/DoubleDefine.jet +++ b/idea/testData/checker/regression/DoubleDefine.jet @@ -1,5 +1,4 @@ -import java.* -import util.* +import java.util.* import java.io.*