From 5cb15c6e480e596e1a0ddab24e45c1d7d10b0cf0 Mon Sep 17 00:00:00 2001 From: svtk Date: Thu, 12 Jan 2012 16:36:25 +0400 Subject: [PATCH] clear previous imports at the beginning of second phase of import resolve --- .../resolve/java/JavaClassDescriptor.java | 9 +- .../jet/lang/descriptors/ClassDescriptor.java | 7 +- .../lang/descriptors/ClassDescriptorImpl.java | 9 +- .../LazySubstitutingClassDescriptor.java | 13 ++- .../descriptors/MutableClassDescriptor.java | 18 ++-- .../jet/lang/resolve/ImportsResolver.java | 91 ++++++++++++------- .../lang/resolve/scopes/WritableScope.java | 2 + .../resolve/scopes/WritableScopeImpl.java | 7 ++ .../scopes/WritableScopeWithImports.java | 6 ++ 9 files changed, 114 insertions(+), 48 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java index 74929c74e66..91508d3bda4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java @@ -132,6 +132,11 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements return null; } + @Override + public ClassDescriptor getClassObjectDescriptor() { + return null; + } + @Override public boolean isClassObjectAValue() { return false; @@ -175,13 +180,13 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements } @Override - public ClassDescriptor getInnerClass(String name) { + public ClassDescriptor getInnerClassOrObject(String name) { return null; } @NotNull @Override - public Collection getInnerClasses() { + public Collection getInnerClassesAndObjects() { return Collections.emptyList(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java index aacd0fdf967..be9e36b7696 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java @@ -51,6 +51,9 @@ public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor @Nullable JetType getClassObjectType(); + @Nullable + ClassDescriptor getClassObjectDescriptor(); + @NotNull ClassKind getKind(); @@ -66,8 +69,8 @@ public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor ReceiverDescriptor getImplicitReceiver(); @Nullable - ClassDescriptor getInnerClass(String name); + ClassDescriptor getInnerClassOrObject(String name); @NotNull - Collection getInnerClasses(); + Collection getInnerClassesAndObjects(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java index bac666c373e..3335f7520f1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java @@ -115,6 +115,11 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl return null; } + @Override + public ClassDescriptor getClassObjectDescriptor() { + return null; + } + @NotNull @Override public ClassKind getKind() { @@ -163,13 +168,13 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl } @Override - public ClassDescriptor getInnerClass(String name) { + public ClassDescriptor getInnerClassOrObject(String name) { return null; } @NotNull @Override - public Collection getInnerClasses() { + public Collection getInnerClassesAndObjects() { return Collections.emptyList(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java index 8009c6b2835..70cf1405c27 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java @@ -153,6 +153,11 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor { return original.getClassObjectType(); } + @Override + public ClassDescriptor getClassObjectDescriptor() { + return original.getClassObjectDescriptor(); + } + @NotNull @Override public ClassKind getKind() { @@ -187,13 +192,13 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor { } @Override - public ClassDescriptor getInnerClass(String name) { - return original.getInnerClass(name); + public ClassDescriptor getInnerClassOrObject(String name) { + return original.getInnerClassOrObject(name); } @NotNull @Override - public Collection getInnerClasses() { - return original.getInnerClasses(); + public Collection getInnerClassesAndObjects() { + return original.getInnerClassesAndObjects(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java index 5fb10e4db9a..c05c4a308a4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java @@ -30,7 +30,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme private final Set functions = Sets.newHashSet(); private List typeParameters = Lists.newArrayList(); private Collection supertypes = Lists.newArrayList(); - private Map innerClasses = Maps.newHashMap(); + private Map innerClassesAndObjects = Maps.newHashMap(); private Modality modality; private Visibility visibility; @@ -109,6 +109,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme } } + @Override @Nullable public MutableClassDescriptor getClassObjectDescriptor() { return classObjectDescriptor; @@ -188,22 +189,25 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) { scopeForMemberLookup.addClassifierDescriptor(classDescriptor); scopeForMemberResolution.addClassifierDescriptor(classDescriptor); - innerClasses.put(classDescriptor.getName(), classDescriptor); + innerClassesAndObjects.put(classDescriptor.getName(), classDescriptor); } + @Override @Nullable - public ClassDescriptor getInnerClass(String name) { - return innerClasses.get(name); + public ClassDescriptor getInnerClassOrObject(String name) { + return innerClassesAndObjects.get(name); } - + + @Override @NotNull - public Collection getInnerClasses() { - return innerClasses.values(); + public Collection getInnerClassesAndObjects() { + return innerClassesAndObjects.values(); } @Override public void addObjectDescriptor(@NotNull MutableClassDescriptor objectDescriptor) { scopeForMemberLookup.addObjectDescriptor(objectDescriptor); + innerClassesAndObjects.put(objectDescriptor.getName(), objectDescriptor); } public void addSupertype(@NotNull JetType supertype) { 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 9af7f66a53d..202d5b942e4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -38,9 +38,10 @@ public class ImportsResolver { ImportResolver importResolver = new ImportResolver(context.getTrace(), firstPhase); for (JetFile file : context.getNamespaceDescriptors().keySet()) { WritableScope namespaceScope = context.getNamespaceScopes().get(file); - if (firstPhase) { - context.getConfiguration().addDefaultImports(context.getTrace(), namespaceScope); + if (!firstPhase) { + namespaceScope.clearImports(); } + context.getConfiguration().addDefaultImports(context.getTrace(), namespaceScope); List importDirectives = file.getImportDirectives(); for (JetImportDirective importDirective : importDirectives) { @@ -51,6 +52,8 @@ public class ImportsResolver { public static class ImportResolver { private final BindingTrace trace; + /* On first phase all classes and objects are imported, + on second phase previous imports are thrown and everything (including functions and properties at namespace level) is imported */ private final boolean firstPhase; public ImportResolver(BindingTrace trace, boolean firstPhase) { @@ -89,14 +92,26 @@ public class ImportsResolver { if (descriptor instanceof NamespaceDescriptor) { namespaceScope.importScope(((NamespaceDescriptor) descriptor).getMemberScope()); } - if (descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() == ClassKind.OBJECT) { - Collection innerClasses = getInnerClasses((ClassDescriptor) descriptor, null); - for (DeclarationDescriptor innerClass : innerClasses) { - namespaceScope.importClassifierAlias(innerClass.getName(), (ClassifierDescriptor) innerClass); + if (descriptor instanceof ClassDescriptor) { + ClassDescriptor objectDescriptor; + if (((ClassDescriptor) descriptor).getKind() == ClassKind.OBJECT) { + objectDescriptor = (ClassDescriptor) descriptor; + } + else { + objectDescriptor = ((ClassDescriptor)descriptor).getClassObjectDescriptor(); + } + if (objectDescriptor != null) { + Collection innerClassesAndObjects = objectDescriptor.getInnerClassesAndObjects(); + for (DeclarationDescriptor innerClassOrObject : innerClassesAndObjects) { + namespaceScope.importClassifierAlias(innerClassOrObject.getName(), (ClassifierDescriptor) innerClassOrObject); + } } } continue; } + if (descriptor instanceof NamespaceDescriptor) { + namespaceScope.importScope(((NamespaceDescriptor) descriptor).getMemberScope()); + } if (descriptor instanceof VariableDescriptor) { JetType type = ((VariableDescriptor) descriptor).getOutType(); namespaceScope.importScope(type.getMemberScope()); @@ -176,12 +191,19 @@ public class ImportsResolver { if (!result.isEmpty()) return result; } if (declarationDescriptor instanceof ClassDescriptor) { - result = lookupObjectMembers(selector, (ClassDescriptor) declarationDescriptor); + if (firstPhase) { + result = lookupInnerClassesAndObjectsInObject(selector, (ClassDescriptor) declarationDescriptor); + } + else { + result = lookupObjectMembers(selector, (ClassDescriptor) declarationDescriptor); + } if (!result.isEmpty()) return result; } - if (declarationDescriptor instanceof VariableDescriptor) { - result = lookupVariableMembers(selector, (VariableDescriptor) declarationDescriptor); - if (!result.isEmpty()) return result; + if (!firstPhase) { + if (declarationDescriptor instanceof VariableDescriptor) { + result = lookupVariableMembers(selector, (VariableDescriptor) declarationDescriptor); + if (!result.isEmpty()) return result; + } } } @@ -227,36 +249,41 @@ public class ImportsResolver { return false; } + @NotNull + private Collection lookupInnerClassesAndObjectsInObject(@NotNull JetSimpleNameExpression objectReference, + @NotNull ClassDescriptor classDescriptor) { + assert firstPhase; + if (classDescriptor.getKind() == ClassKind.OBJECT) { + return getInnerClassesAndObjectsByName(classDescriptor, objectReference); + } + MutableClassDescriptor classObjectDescriptor = ((MutableClassDescriptor) classDescriptor).getClassObjectDescriptor(); + assert classObjectDescriptor != null; + return getInnerClassesAndObjectsByName(classObjectDescriptor, objectReference); + } + @NotNull private Collection lookupObjectMembers(@NotNull JetSimpleNameExpression memberReference, @NotNull ClassDescriptor classDescriptor) { - if (classDescriptor.getKind() == ClassKind.OBJECT) { - return getInnerClasses(classDescriptor, memberReference); - } - if (firstPhase) return Collections.emptyList(); + assert !firstPhase; + //on second phase class descriptor is only a descriptor for class object JetType classObjectType = classDescriptor.getClassObjectType(); - assert classObjectType != null; + if (classObjectType == null) return Collections.emptyList(); return lookupDescriptorsForSimpleNameReference(memberReference, classObjectType.getMemberScope(), true); } @NotNull - private Collection getInnerClasses(@NotNull ClassDescriptor classDescriptor, @Nullable JetSimpleNameExpression memberReference) { + private Collection getInnerClassesAndObjectsByName(@NotNull ClassDescriptor classDescriptor, @NotNull JetSimpleNameExpression memberReference) { if (classDescriptor.getKind() != ClassKind.OBJECT) return Collections.emptyList(); Collection descriptors; - if (memberReference != null) { - ClassDescriptor innerClass = classDescriptor.getInnerClass(memberReference.getReferencedName()); - if (innerClass == null) return Collections.emptyList(); - descriptors = Collections.singletonList(innerClass); - storeResolutionResult(descriptors, memberReference, JetScope.EMPTY, true); - } - else { - descriptors = classDescriptor.getInnerClasses(); - } + ClassDescriptor innerClass = classDescriptor.getInnerClassOrObject(memberReference.getReferencedName()); + if (innerClass == null) return Collections.emptyList(); + descriptors = Collections.singletonList(innerClass); + storeResolutionResult(descriptors, memberReference, JetScope.EMPTY, true); return descriptors; } private Collection lookupVariableMembers(@NotNull JetSimpleNameExpression memberReference, @NotNull VariableDescriptor variableDescriptor) { - if (firstPhase) return Collections.emptyList(); + assert !firstPhase; JetType variableType = variableDescriptor.getReturnType(); if (variableType == null) return Collections.emptyList(); @@ -299,12 +326,14 @@ public class ImportsResolver { ClassifierDescriptor classifierDescriptor = outerScope.getClassifier(referencedName); if (classifierDescriptor != null) descriptors.add(classifierDescriptor); - ClassDescriptor objectDescriptor = outerScope.getObjectDescriptor(referencedName); - if (objectDescriptor != null) descriptors.add(objectDescriptor); + if (firstPhase) { + descriptors.add(outerScope.getObjectDescriptor(referencedName)); + } + else { + descriptors.addAll(outerScope.getFunctions(referencedName)); - descriptors.addAll(outerScope.getFunctions(referencedName)); - - descriptors.addAll(outerScope.getProperties(referencedName)); + descriptors.addAll(outerScope.getProperties(referencedName)); + } } storeResolutionResult(descriptors, referenceExpression, bindingScope, isLastPart); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java index 90bf35dea4e..dbba350aaa5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java @@ -55,4 +55,6 @@ public interface WritableScope extends JetScope { void importFunctionAlias(@NotNull String aliasName, @NotNull FunctionDescriptor functionDescriptor); void importVariableAlias(@NotNull String aliasName, @NotNull VariableDescriptor variableDescriptor); + + void clearImports(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java index 79a0fb476af..119de952eb6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java @@ -99,6 +99,13 @@ public class WritableScopeImpl extends WritableScopeWithImports { super.importVariableAlias(aliasName, variableDescriptor); } + @Override + public void clearImports() { + checkMayWrite(); + + super.clearImports(); + } + @NotNull @Override public Collection getAllDescriptors() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java index 4b594ccf462..b269d48b6bf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java @@ -212,6 +212,12 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement getCurrentIndividualImportScope().addVariableAlias(aliasName, variableDescriptor); } + @Override + public void clearImports() { + currentIndividualImportScope = null; + getImports().clear(); + } + @Override public String toString() { return getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(this)) + " " + debugName + " for " + getContainingDeclaration();