Refactoring/Cleanup

idea/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java

@@ -1,5 +1,6 @@
 package org.jetbrains.jet.lang.descriptors;
 
+import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -7,9 +8,7 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
-import java.util.List;
+import java.util.*;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * @author abreslav
@@ -19,9 +18,11 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     private final WritableFunctionGroup constructors = new WritableFunctionGroup("<init>");
     private final Set<FunctionDescriptor> functions = Sets.newHashSet();
     private final Set<PropertyDescriptor> properties = Sets.newHashSet();
+    private List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
+    private Collection<JetType> supertypes = Lists.newArrayList();
 
+    private boolean open;
     private TypeConstructor typeConstructor;
-
     private final WritableScope scopeForMemberResolution;
     private final WritableScope scopeForMemberLookup;
     // This scope contains type parameters but does not contain inner classes
@@ -31,7 +32,8 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
         super(containingDeclaration);
         this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, trace.getErrorHandler());
         this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, trace.getErrorHandler());
-        this.scopeForMemberResolution = new WritableScopeImpl(scopeForSupertypeResolution, this, trace.getErrorHandler());
+        this.scopeForMemberResolution = new WritableScopeImpl(scopeForMemberLookup, this, trace.getErrorHandler());
+        scopeForMemberResolution.importScope(scopeForSupertypeResolution);
     }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -57,7 +59,6 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
         properties.add(propertyDescriptor);
         scopeForMemberLookup.addVariableDescriptor(propertyDescriptor);
-        scopeForMemberResolution.addVariableDescriptor(propertyDescriptor);
     }
 
     @NotNull
@@ -69,7 +70,6 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     public void addFunctionDescriptor(@NotNull FunctionDescriptor functionDescriptor) {
         functions.add(functionDescriptor);
         scopeForMemberLookup.addFunctionDescriptor(functionDescriptor);
-        scopeForMemberResolution.addFunctionDescriptor(functionDescriptor);
     }
 
     @NotNull
@@ -90,22 +90,53 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     @Override
     public void addClassifierDescriptor(@NotNull MutableClassDescriptor classDescriptor) {
         scopeForMemberLookup.addClassifierDescriptor(classDescriptor);
-        scopeForMemberResolution.addClassifierDescriptor(classDescriptor);
     }
 
+    public void addSupertype(@NotNull JetType supertype) {
+        scopeForMemberLookup.importScope(supertype.getMemberScope());
+        supertypes.add(supertype);
+    }
+
+    public void setTypeParameterDescriptors(List<TypeParameterDescriptor> typeParameters) {
+        for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
+            this.typeParameters.add(typeParameterDescriptor);
+            scopeForSupertypeResolution.addTypeParameterDescriptor(typeParameterDescriptor);
+        }
+        scopeForMemberResolution.setThisType(getDefaultType());
+    }
+
+
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    @Override
+    public void setName(@NotNull String name) {
+        super.setName(name);
+        scopeForMemberResolution.addLabeledDeclaration(this);
+    }
+
+    public boolean isOpen() {
+        return open;
+    }
+
+    public void setOpen(boolean open) {
+        this.open = open;
+    }
+
     @NotNull
     @Override
     public TypeConstructor getTypeConstructor() {
-        assert typeConstructor != null : "Type constructor is not set for " + getName();
+        if (typeConstructor == null) {
+            this.typeConstructor = new TypeConstructorImpl(
+                    this,
+                    Collections.<Annotation>emptyList(), // TODO : pass annotations from the class?
+                    !open,
+                    getName(),
+                    typeParameters,
+                    supertypes);
+        }
         return typeConstructor;
     }
 
-    public void setTypeConstructor(@NotNull TypeConstructor typeConstructor) {
-        this.typeConstructor = typeConstructor;
-    }
-
     @NotNull
     @Override
     public JetScope getMemberScope(List<TypeProjection> typeArguments) {
@@ -137,12 +168,17 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     }
 
     @NotNull
-    public WritableScope getScopeForMemberLookup() {
+    public JetScope getScopeForSupertypeResolution() {
+        return scopeForSupertypeResolution;
+    }
+
+    @NotNull
+    public JetScope getScopeForMemberLookup() {
         return scopeForMemberLookup;
     }
 
     @NotNull
-    public WritableScope getScopeForMemberResolution() {
+    public JetScope getScopeForMemberResolution() {
         return scopeForMemberResolution;
     }
 
@@ -166,14 +202,4 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     public String toString() {
         return DescriptorRenderer.TEXT.render(this) + "[" + getClass().getCanonicalName() + "@" + System.identityHashCode(this) + "]";
     }
-
-    public void addSupertype(@NotNull JetType supertype) {
-        scopeForMemberLookup.importScope(supertype.getMemberScope());
-        scopeForMemberResolution.importScope(supertype.getMemberScope());
-    }
-
-    @NotNull
-    public WritableScope getScopeForSupertypeResolution() {
-        return scopeForSupertypeResolution;
-    }
 }

idea/src/org/jetbrains/jet/lang/descriptors/MutableDeclarationDescriptor.java

@@ -27,6 +27,7 @@ public abstract class MutableDeclarationDescriptor implements DeclarationDescrip
     }
 
     public void setName(@NotNull String name) {
+        assert this.name == null : this.name;
         this.name = name;
     }
 

idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java

@@ -109,11 +109,6 @@ public class ClassDescriptorResolver {
     }
 
     public void resolveMutableClassDescriptor(@NotNull JetClass classElement, @NotNull MutableClassDescriptor descriptor) {
-        descriptor.setName(JetPsiUtil.safeName(classElement.getName()));
-        descriptor.getScopeForMemberResolution().addLabeledDeclaration(descriptor);
-
-        WritableScope scopeForMemberResolution = descriptor.getScopeForSupertypeResolution();
-
         // TODO : Where-clause
         List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
         int index = 0;
@@ -125,26 +120,13 @@ public class ClassDescriptorResolver {
                     JetPsiUtil.safeName(typeParameter.getName()),
                     index
             );
-            scopeForMemberResolution.addTypeParameterDescriptor(typeParameterDescriptor);
             trace.recordDeclarationResolution(typeParameter, typeParameterDescriptor);
             typeParameters.add(typeParameterDescriptor);
             index++;
         }
+        descriptor.setTypeParameterDescriptors(typeParameters);
 
-        boolean open = classElement.hasModifier(JetTokens.OPEN_KEYWORD);
+        descriptor.setOpen(classElement.hasModifier(JetTokens.OPEN_KEYWORD));
-        List<JetType> supertypes = new ArrayList<JetType>();
-        TypeConstructorImpl typeConstructor = new TypeConstructorImpl(
-                descriptor,
-                AnnotationResolver.INSTANCE.resolveAnnotations(classElement.getModifierList()),
-                !open,
-                JetPsiUtil.safeName(classElement.getName()),
-                typeParameters,
-                supertypes);
-        descriptor.setTypeConstructor(
-                typeConstructor
-        );
-
-        descriptor.getScopeForMemberResolution().setThisType(descriptor.getDefaultType());
 
         trace.recordDeclarationResolution(classElement, descriptor);
     }
@@ -171,8 +153,10 @@ public class ClassDescriptorResolver {
 //        TODO : assuming that the hierarchy is acyclic
         Collection<? extends JetType> superclasses = delegationSpecifiers.isEmpty()
                 ? Collections.singleton(JetStandardClasses.getAnyType())
-                : resolveDelegationSpecifiers(descriptor.getScopeForSupertypeResolution(), delegationSpecifiers, typeResolverNotCheckingBounds);
+                : resolveDelegationSpecifiers(
-        ((TypeConstructorImpl) descriptor.getTypeConstructor()).getSupertypes().addAll(superclasses);
+                    descriptor.getScopeForSupertypeResolution(),
+                    delegationSpecifiers,
+                    typeResolverNotCheckingBounds);
 
         // TODO : remove the importing
         for (JetType superclass : superclasses) {
@@ -295,7 +279,7 @@ public class ClassDescriptorResolver {
         return typeParameterDescriptor;
     }
 
-    private Collection<JetType> resolveDelegationSpecifiers(WritableScope extensibleScope, List<JetDelegationSpecifier> delegationSpecifiers, @NotNull TypeResolver resolver) {
+    private Collection<JetType> resolveDelegationSpecifiers(JetScope extensibleScope, List<JetDelegationSpecifier> delegationSpecifiers, @NotNull TypeResolver resolver) {
         if (delegationSpecifiers.isEmpty()) {
             return Collections.emptyList();
         }

idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java

@@ -150,7 +150,7 @@ public class TopDownAnalyzer {
                     classes.put(klass, mutableClassDescriptor);
                     declaringScopes.put(klass, outerScope);
 
-                    WritableScope classScope = mutableClassDescriptor.getScopeForMemberResolution();
+                    JetScope classScope = mutableClassDescriptor.getScopeForMemberResolution();
                     collectNamespacesAndClassifiers(classScope, mutableClassDescriptor, klass.getDeclarations());
                 }
 
@@ -261,7 +261,7 @@ public class TopDownAnalyzer {
         if (!klass.hasPrimaryConstructor()) return;
 
         // TODO : not all the parameters are real properties
-        WritableScope memberScope = classDescriptor.getScopeForMemberResolution(); // TODO : this is REALLY questionable
+        JetScope memberScope = classDescriptor.getScopeForMemberResolution(); // TODO : this is REALLY questionable
         ConstructorDescriptor constructorDescriptor = classDescriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass);
         for (JetParameter parameter : klass.getPrimaryConstructorParameters()) {
             PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePrimaryConstructorParameterToAProperty(