From 197eaa0b2e2a746508c4b79c8cf0c63f6eabe098 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 30 Oct 2013 22:41:20 +0400 Subject: [PATCH] Drop BodiesResolveContext.getObjects() Objects are stored in the same place where classes are --- .../lang/resolve/BodiesResolveContext.java | 5 +-- .../jet/lang/resolve/BodyResolver.java | 33 ++++++------------- .../resolve/CachedBodiesResolveContext.java | 7 ---- .../jet/lang/resolve/ControlFlowAnalyzer.java | 4 --- .../jet/lang/resolve/DeclarationResolver.java | 29 ++++------------ .../jet/lang/resolve/DeclarationsChecker.java | 10 ------ .../jet/lang/resolve/OverloadResolver.java | 3 -- .../jet/lang/resolve/OverrideResolver.java | 17 +++------- .../lang/resolve/TopDownAnalysisContext.java | 6 ---- .../jet/lang/resolve/TopDownAnalyzer.java | 3 -- .../lang/resolve/TypeHierarchyResolver.java | 21 +++--------- .../plugin/project/ResolveElementCache.java | 5 --- 12 files changed, 28 insertions(+), 115 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java index 54761cd0d60..dfafd5c1609 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodiesResolveContext.java @@ -19,7 +19,9 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Function; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; @@ -32,7 +34,6 @@ import java.util.Map; public interface BodiesResolveContext { Collection getFiles(); Map getClasses(); - Map getObjects(); Map getProperties(); Map getFunctions(); Function getDeclaringScopes(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index 5d9aadd9161..b7974402cb7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -160,18 +160,13 @@ public class BodyResolver { private void resolveDelegationSpecifierLists() { // TODO : Make sure the same thing is not initialized twice for (Map.Entry entry : context.getClasses().entrySet()) { - resolveDelegationSpecifierList(entry.getKey(), entry.getValue()); + JetClassOrObject classOrObject = entry.getKey(); + MutableClassDescriptor descriptor = entry.getValue(); + resolveDelegationSpecifierList(classOrObject, descriptor, + descriptor.getUnsubstitutedPrimaryConstructor(), + descriptor.getScopeForSupertypeResolution(), + descriptor.getScopeForMemberResolution()); } - for (Map.Entry entry : context.getObjects().entrySet()) { - resolveDelegationSpecifierList(entry.getKey(), entry.getValue()); - } - } - - private void resolveDelegationSpecifierList(JetClassOrObject jetClass, MutableClassDescriptor descriptor) { - resolveDelegationSpecifierList(jetClass, descriptor, - descriptor.getUnsubstitutedPrimaryConstructor(), - descriptor.getScopeForSupertypeResolution(), - descriptor.getScopeForMemberResolution()); } public void resolveDelegationSpecifierList(@NotNull JetClassOrObject jetClass, @NotNull final ClassDescriptor descriptor, @@ -338,23 +333,15 @@ public class BodyResolver { for (Map.Entry entry : context.getClasses().entrySet()) { resolveAnnotationArguments(entry.getValue().getScopeForSupertypeResolution(), entry.getKey()); } - for (Map.Entry entry : context.getObjects().entrySet()) { - resolveAnnotationArguments(entry.getValue().getScopeForSupertypeResolution(), entry.getKey()); - } } private void resolveAnonymousInitializers() { for (Map.Entry entry : context.getClasses().entrySet()) { - resolveAnonymousInitializers(entry.getKey(), entry.getValue()); + JetClassOrObject classOrObject = entry.getKey(); + MutableClassDescriptor descriptor = entry.getValue(); + resolveAnonymousInitializers(classOrObject, descriptor.getUnsubstitutedPrimaryConstructor(), + descriptor.getScopeForInitializers()); } - for (Map.Entry entry : context.getObjects().entrySet()) { - resolveAnonymousInitializers(entry.getKey(), entry.getValue()); - } - } - - private void resolveAnonymousInitializers(JetClassOrObject jetClassOrObject, MutableClassDescriptor classDescriptor) { - resolveAnonymousInitializers(jetClassOrObject, classDescriptor.getUnsubstitutedPrimaryConstructor(), - classDescriptor.getScopeForInitializers()); } public void resolveAnonymousInitializers(JetClassOrObject jetClassOrObject, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java index 875f0a74e02..b623020f5ba 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/CachedBodiesResolveContext.java @@ -40,7 +40,6 @@ import java.util.Map; public class CachedBodiesResolveContext implements BodiesResolveContext { private final Collection files; private final Map classes; - private final Map objects; private final Map properties; private final Map functions; private final Function declaringScopes; @@ -53,7 +52,6 @@ public class CachedBodiesResolveContext implements BodiesResolveContext { public CachedBodiesResolveContext(TopDownAnalysisContext context) { files = Collections.unmodifiableCollection(context.getFiles()); classes = Collections.unmodifiableMap(context.getClasses()); - objects = Collections.unmodifiableMap(context.getObjects()); properties = Collections.unmodifiableMap(context.getProperties()); functions = Collections.unmodifiableMap(context.getFunctions()); declaringScopes = context.getDeclaringScopes(); @@ -74,11 +72,6 @@ public class CachedBodiesResolveContext implements BodiesResolveContext { return classes; } - @Override - public Map getObjects() { - return objects; - } - @Override public Map getProperties() { return properties; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java index 07b5d4cf04f..8d5190faedc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java @@ -52,10 +52,6 @@ public class ControlFlowAnalyzer { if (!bodiesResolveContext.completeAnalysisNeeded(aClass)) continue; checkDeclarationContainer(aClass); } - for (JetObjectDeclaration objectDeclaration : bodiesResolveContext.getObjects().keySet()) { - if (!bodiesResolveContext.completeAnalysisNeeded(objectDeclaration)) continue; - checkDeclarationContainer(objectDeclaration); - } for (Map.Entry entry : bodiesResolveContext.getFunctions().entrySet()) { JetNamedFunction function = entry.getKey(); SimpleFunctionDescriptor functionDescriptor = entry.getValue(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java index 6ab20d92c85..6e313b11ad2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -150,18 +150,12 @@ public class DeclarationResolver { private void resolveAnnotationStubsOnClassesAndConstructors() { for (Map.Entry entry : context.getClasses().entrySet()) { - resolveAnnotationsForClassOrObject(annotationResolver, entry.getKey(), entry.getValue()); - } - for (Map.Entry entry : context.getObjects().entrySet()) { - resolveAnnotationsForClassOrObject(annotationResolver, entry.getKey(), entry.getValue()); - } - } - - private void resolveAnnotationsForClassOrObject(AnnotationResolver annotationResolver, JetClassOrObject jetClass, MutableClassDescriptor descriptor) { - JetModifierList modifierList = jetClass.getModifierList(); - if (modifierList != null) { - descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotationsWithoutArguments( - descriptor.getScopeForSupertypeResolution(), modifierList, trace)); + JetModifierList modifierList = entry.getKey().getModifierList(); + if (modifierList != null) { + MutableClassDescriptor descriptor = entry.getValue(); + descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotationsWithoutArguments( + descriptor.getScopeForSupertypeResolution(), modifierList, trace)); + } } } @@ -187,14 +181,6 @@ public class DeclarationResolver { classDescriptor.getScopeForInitializers(), classDescriptor.getScopeForMemberResolution(), classDescriptor.getBuilder()); } - for (Map.Entry entry : context.getObjects().entrySet()) { - JetObjectDeclaration object = entry.getKey(); - MutableClassDescriptor classDescriptor = entry.getValue(); - - resolveFunctionAndPropertyHeaders(object.getDeclarations(), classDescriptor.getScopeForMemberResolution(), - classDescriptor.getScopeForInitializers(), classDescriptor.getScopeForMemberResolution(), - classDescriptor.getBuilder()); - } scriptHeaderResolver.resolveScriptDeclarations(); @@ -389,8 +375,7 @@ public class DeclarationResolver { } private void checkRedeclarationsInInnerClassNames() { - Iterable classesAndObjects = Iterables.concat(context.getClasses().values(), context.getObjects().values()); - for (MutableClassDescriptor classDescriptor : classesAndObjects) { + for (MutableClassDescriptor classDescriptor : context.getClasses().values()) { if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) { // Class objects should be considered during analysing redeclarations in classes continue; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index e5887dac5db..98fbab4e1ae 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -64,16 +64,6 @@ public class DeclarationsChecker { modifiersChecker.checkModifiersForDeclaration(classOrObject, classDescriptor); } - Map objects = bodiesResolveContext.getObjects(); - for (Map.Entry entry : objects.entrySet()) { - JetObjectDeclaration objectDeclaration = entry.getKey(); - MutableClassDescriptor objectDescriptor = entry.getValue(); - - if (!bodiesResolveContext.completeAnalysisNeeded(objectDeclaration)) continue; - checkObject(objectDeclaration); - modifiersChecker.checkModifiersForDeclaration(objectDeclaration, objectDescriptor); - } - Map functions = bodiesResolveContext.getFunctions(); for (Map.Entry entry : functions.entrySet()) { JetNamedFunction function = entry.getKey(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index 93b1f33f8e7..fc3c2c84baa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -62,9 +62,6 @@ public class OverloadResolver { for (Map.Entry entry : context.getClasses().entrySet()) { checkOverloadsInAClass(entry.getValue(), entry.getKey(), inClasses.get(entry.getValue())); } - for (Map.Entry entry : context.getObjects().entrySet()) { - checkOverloadsInAClass(entry.getValue(), entry.getKey(), inClasses.get(entry.getValue())); - } checkOverloadsInANamespace(inNamespaces); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index 2ffa95e551c..c31adf87bb3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -84,10 +84,7 @@ public class OverrideResolver { * Generate fake overrides and add overridden descriptors to existing descriptors. */ private void generateOverridesAndDelegation() { - Set ourClasses = new HashSet(); - ourClasses.addAll(context.getClasses().values()); - ourClasses.addAll(context.getObjects().values()); - + Set ourClasses = new HashSet(context.getClasses().values()); Set processed = new HashSet(); for (MutableClassDescriptorLite klass : ContainerUtil.reverse(context.getClassesTopologicalOrder())) { @@ -224,9 +221,6 @@ public class OverrideResolver { for (Map.Entry entry : context.getClasses().entrySet()) { checkOverridesInAClass(entry.getValue(), entry.getKey()); } - for (Map.Entry entry : context.getObjects().entrySet()) { - checkOverridesInAClass(entry.getValue(), entry.getKey()); - } } protected void checkOverridesInAClass(@NotNull MutableClassDescriptor classDescriptor, @NotNull JetClassOrObject klass) { @@ -655,17 +649,14 @@ public class OverrideResolver { } private void checkParameterOverridesForAllClasses() { - List allClasses = Lists.newArrayList(context.getClasses().values()); - allClasses.addAll(context.getObjects().values()); - for (MutableClassDescriptor classDescriptor : allClasses) { - Collection members = classDescriptor.getAllCallableMembers(); - for (CallableMemberDescriptor member : members) { + for (MutableClassDescriptor classDescriptor : context.getClasses().values()) { + for (CallableMemberDescriptor member : classDescriptor.getAllCallableMembers()) { checkOverridesForParameters(member); } } } - private void checkOverridesForParameters(CallableMemberDescriptor declared) { + private void checkOverridesForParameters(@NotNull CallableMemberDescriptor declared) { boolean noDeclaration = declared.getKind() != CallableMemberDescriptor.Kind.DECLARATION; if (!noDeclaration) { // No check if the function is not marked as 'override' diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index 399274d498e..1cc96234617 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -42,7 +42,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext { private DataFlowInfo outerDataFlowInfo = DataFlowInfo.EMPTY; private final Map classes = Maps.newLinkedHashMap(); - private final Map objects = Maps.newLinkedHashMap(); protected final Map namespaceDescriptors = Maps.newHashMap(); private List classesTopologicalOrder = null; @@ -111,11 +110,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext { return classes; } - @Override - public Map getObjects() { - return objects; - } - public Map getNamespaceScopes() { return namespaceScopes; } 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 c1d391ce1d3..c60af64e510 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -142,9 +142,6 @@ public class TopDownAnalyzer { for (MutableClassDescriptor mutableClassDescriptor : context.getClasses().values()) { mutableClassDescriptor.lockScopes(); } - for (MutableClassDescriptor mutableClassDescriptor : context.getObjects().values()) { - mutableClassDescriptor.lockScopes(); - } for (Map.Entry namespaceScope : context.getNamespaceScopes().entrySet()) { // todo: this is hack in favor of REPL if(!namespaceScope.getKey().isScript()) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index 250ce6cd369..3dabd556208 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -21,7 +21,6 @@ import com.google.common.collect.Multimap; import com.google.common.collect.Sets; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiNameIdentifierOwner; -import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -188,9 +187,6 @@ public class TypeHierarchyResolver { initializeObject((JetObjectDeclaration) classOrObject, descriptor); } } - for (Map.Entry entry : context.getObjects().entrySet()) { - initializeObject(entry.getKey(), entry.getValue()); - } } private static void initializeObject(@NotNull JetObjectDeclaration declaration, @NotNull MutableClassDescriptor descriptor) { @@ -209,23 +205,20 @@ public class TypeHierarchyResolver { JetClassOrObject classOrObject = entry.getKey(); MutableClassDescriptor descriptor = entry.getValue(); if (classOrObject instanceof JetClass) { + //noinspection unchecked descriptorResolver.resolveGenericBounds((JetClass) classOrObject, descriptor.getScopeForSupertypeResolution(), (List) descriptor.getTypeConstructor().getParameters(), trace); } descriptorResolver.resolveSupertypesForMutableClassDescriptor(classOrObject, descriptor, trace); } - for (Map.Entry entry : context.getObjects().entrySet()) { - JetClassOrObject jetClass = entry.getKey(); - MutableClassDescriptor descriptor = entry.getValue(); - descriptorResolver.resolveSupertypesForMutableClassDescriptor(jetClass, descriptor, trace); - } } private List topologicallySortClassesAndObjects() { // A topsort is needed only for better diagnostics: // edges that get removed to disconnect loops are more reasonable in this case + //noinspection unchecked return DFS.topologicalOrder( - ContainerUtil.concat(context.getClasses().values(), context.getObjects().values()), + (Iterable) context.getClasses().values(), new DFS.Neighbors() { @NotNull @Override @@ -425,12 +418,6 @@ public class TypeHierarchyResolver { checkBoundsForTypeInClassHeader(constraint.getBoundTypeReference()); } } - - for (JetObjectDeclaration object : context.getObjects().keySet()) { - for (JetDelegationSpecifier delegationSpecifier : object.getDelegationSpecifiers()) { - checkBoundsForTypeInClassHeader(delegationSpecifier.getTypeReference()); - } - } } private void checkBoundsForTypeInClassHeader(@Nullable JetTypeReference typeReference) { @@ -523,7 +510,7 @@ public class TypeHierarchyResolver { MutableClassDescriptor classObjectDescriptor = createClassDescriptorForObject(objectDeclaration, getClassObjectName(owner.getOwnerForChildren().getName()), ClassKind.CLASS_OBJECT); - context.getObjects().put(objectDeclaration, classObjectDescriptor); + context.getClasses().put(objectDeclaration, classObjectDescriptor); NamespaceLikeBuilder.ClassObjectStatus status = owner.setClassObjectDescriptor(classObjectDescriptor); switch (status) { diff --git a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index 5936b142d81..ca63d46f815 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -432,11 +432,6 @@ public class ResolveElementCache { return Collections.emptyMap(); } - @Override - public Map getObjects() { - return Collections.emptyMap(); - } - @Override public Map getProperties() { return Collections.emptyMap();