Cleanup ClassDescriptorImpl & ErrorClassDescriptor

ClassDescriptorImpl now extends ClassDescriptorBase and reuses most of its
functionality. ErrorClassDescriptor now is initialized in its own constructor.
Inline trivial arguments everywhere

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java

@@ -25,7 +25,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.SamCodegenUtil;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -93,21 +92,10 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid {
 
     @NotNull
     private ClassDescriptor recordClassForFunction(@NotNull FunctionDescriptor funDescriptor, @NotNull JetType superType) {
-        ClassDescriptor classDescriptor;
+        ClassDescriptorImpl classDescriptor =
-
+                new ClassDescriptorImpl(funDescriptor.getContainingDeclaration(), Name.special("<closure>"), Modality.FINAL,
-        classDescriptor = new ClassDescriptorImpl(
+                                        Collections.singleton(superType));
-                funDescriptor.getContainingDeclaration(),
+        classDescriptor.initialize(JetScope.EMPTY, Collections.<ConstructorDescriptor>emptySet(), null);
-                Collections.<AnnotationDescriptor>emptyList(),
-                Modality.FINAL,
-                Name.special("<closure>"));
-        ((ClassDescriptorImpl)classDescriptor).initialize(
-                false,
-                Collections.<TypeParameterDescriptor>emptyList(),
-                Collections.singleton(superType),
-                JetScope.EMPTY,
-                Collections.<ConstructorDescriptor>emptySet(),
-                null,
-                false);
 
         bindingTrace.record(CLASS_FOR_FUNCTION, funDescriptor, classDescriptor);
         return classDescriptor;

compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java

@@ -22,7 +22,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -141,19 +140,10 @@ public class CodegenBinding {
             @NotNull ScriptDescriptor scriptDescriptor,
             @NotNull Type asmType
     ) {
-        ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
+        ClassDescriptorImpl classDescriptor =
-                scriptDescriptor,
+                new ClassDescriptorImpl(scriptDescriptor, Name.special("<script-" + asmType.getInternalName() + ">"), Modality.FINAL,
-                Collections.<AnnotationDescriptor>emptyList(),
+                                        Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()));
-                Modality.FINAL,
+        classDescriptor.initialize(JetScope.EMPTY, Collections.<ConstructorDescriptor>emptySet(), null);
-                Name.special("<script-" + asmType.getInternalName() + ">"));
-        classDescriptor.initialize(
-                false,
-                Collections.<TypeParameterDescriptor>emptyList(),
-                Collections.singletonList(KotlinBuiltIns.getInstance().getAnyType()),
-                JetScope.EMPTY,
-                Collections.<ConstructorDescriptor>emptySet(),
-                null,
-                false);
 
         recordClosure(bindingTrace, null, classDescriptor, null, asmType);
 

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java

@@ -27,8 +27,8 @@ import org.jetbrains.jet.lang.resolve.DescriptorFactory;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.Variance;
+import org.jetbrains.jet.lang.types.error.ErrorClassDescriptor;
 import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.ArrayList;
@@ -207,7 +207,7 @@ public class DescriptorDeserializer {
             if (objectClass == null) {
                 // if we are not able to find the class for object property
                 // then something bad has happened since they should be in the same jar
-                objectClass = ErrorUtils.createErrorClass(objectId.asSingleFqName().asString());
+                objectClass = new ErrorClassDescriptor(objectId.asSingleFqName().asString());
             }
             return new PropertyDescriptorForObjectImpl(containingDeclaration, annotations, visibility, name, objectClass);
         }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java

@@ -145,14 +145,10 @@ public final class JavaPropertyResolver {
             //TODO: this is a hack to indicate that this enum entry is an object
             // class descriptor for enum entries is not used by backends so for now this should be safe to use
             ClassDescriptorImpl dummyClassDescriptorForEnumEntryObject =
-                    new ClassDescriptorImpl(owner, Collections.<AnnotationDescriptor>emptyList(), Modality.FINAL, propertyName);
+                    new ClassDescriptorImpl(owner, propertyName, Modality.FINAL, Collections.<JetType>emptyList());
-            dummyClassDescriptorForEnumEntryObject.initialize(
+            dummyClassDescriptorForEnumEntryObject.initialize(JetScope.EMPTY, Collections.<ConstructorDescriptor>emptySet(), null);
-                    true,
+            return new JavaPropertyDescriptorForObject(owner, annotations, visibility, propertyName,
-                    Collections.<TypeParameterDescriptor>emptyList(),
+                                                       dummyClassDescriptorForEnumEntryObject);
-                    Collections.<JetType>emptyList(), JetScope.EMPTY,
-                    Collections.<ConstructorDescriptor>emptySet(), null,
-                    false);
-            return new JavaPropertyDescriptorForObject(owner, annotations, visibility, propertyName, dummyClassDescriptorForEnumEntryObject);
         }
 
         return new JavaPropertyDescriptor(owner, annotations, visibility, isVar, propertyName);

core/descriptors/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java

@@ -64,21 +64,11 @@ public class ScriptDescriptor extends DeclarationDescriptorNonRootImpl {
         super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), NAME);
         this.priority = priority;
 
-        classDescriptor = new ClassDescriptorImpl(
+        classDescriptor = new ClassDescriptorImpl(containingDeclaration, className, Modality.FINAL,
-                containingDeclaration,
+                                                  Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()));
-                Collections.<AnnotationDescriptor>emptyList(),
-                Modality.FINAL,
-                className);
         classScope = new WritableScopeImpl(scriptScope, containingDeclaration, RedeclarationHandler.DO_NOTHING, "script members");
         classScope.changeLockLevel(WritableScope.LockLevel.BOTH);
-        classDescriptor.initialize(
+        classDescriptor.initialize(classScope, new HashSet<ConstructorDescriptor>(), null);
-                false,
-                Collections.<TypeParameterDescriptor>emptyList(),
-                Collections.singletonList(KotlinBuiltIns.getInstance().getAnyType()),
-                classScope,
-                new HashSet<ConstructorDescriptor>(),
-                null,
-                false);
     }
 
     public void initialize(

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ClassDescriptorImpl.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.descriptors.impl;
 
+import jet.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -23,70 +24,64 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorFactory;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
+import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.types.TypeConstructor;
+import org.jetbrains.jet.lang.types.TypeConstructorImpl;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.NotNullLazyValue;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
-public class ClassDescriptorImpl extends DeclarationDescriptorNonRootImpl implements ClassDescriptor {
+public class ClassDescriptorImpl extends ClassDescriptorBase {
-    private TypeConstructor typeConstructor;
+    private final Modality modality;
+    private final TypeConstructor typeConstructor;
+    private final NotNullLazyValue<ReceiverParameterDescriptor> thisAsReceiverParameter;
 
-    private JetScope memberDeclarations;
+    private JetScope scopeForMemberLookup;
     private Set<ConstructorDescriptor> constructors;
     private ConstructorDescriptor primaryConstructor;
-    private ReceiverParameterDescriptor thisAsReceiverParameter;
-    private final Modality modality;
-    private ClassDescriptor classObjectDescriptor;
-    private final ClassKind kind;
-    private boolean isInner;
-
-    public ClassDescriptorImpl(
-        @NotNull DeclarationDescriptor containingDeclaration,
-        @NotNull List<AnnotationDescriptor> annotations,
-        @NotNull Modality modality,
-        @NotNull Name name
-    ) {
-        this(containingDeclaration, ClassKind.CLASS, annotations, modality, name);
-    }
 
     public ClassDescriptorImpl(
             @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull ClassKind kind,
+            @NotNull Name name,
-            @NotNull List<AnnotationDescriptor> annotations,
             @NotNull Modality modality,
-            @NotNull Name name) {
+            @NotNull Collection<JetType> supertypes
-        super(containingDeclaration, annotations, name);
+    ) {
-        this.kind = kind;
+        super(LockBasedStorageManager.NO_LOCKS, containingDeclaration, name);
         this.modality = modality;
+
+        this.typeConstructor = new TypeConstructorImpl(this, Collections.<AnnotationDescriptor>emptyList(), false, getName().asString(),
+                                                       Collections.<TypeParameterDescriptor>emptyList(), supertypes);
+
+        this.thisAsReceiverParameter = LockBasedStorageManager.NO_LOCKS.createLazyValue(new Function0<ReceiverParameterDescriptor>() {
+            @Override
+            public ReceiverParameterDescriptor invoke() {
+                return DescriptorFactory.createLazyReceiverParameterDescriptor(ClassDescriptorImpl.this);
+            }
+        });
     }
 
-
+    public final void initialize(
-    public final ClassDescriptorImpl initialize(
+            @NotNull JetScope scopeForMemberLookup,
-            boolean isFinal,
-            @NotNull List<? extends TypeParameterDescriptor> typeParameters,
-            @NotNull Collection<JetType> supertypes,
-            @NotNull JetScope memberDeclarations,
             @NotNull Set<ConstructorDescriptor> constructors,
-            @Nullable ConstructorDescriptor primaryConstructor,
+            @Nullable ConstructorDescriptor primaryConstructor
-            boolean isInner
     ) {
-        this.typeConstructor = new TypeConstructorImpl(this, getAnnotations(), isFinal, getName().asString(), typeParameters, supertypes);
+        this.scopeForMemberLookup = scopeForMemberLookup;
-        this.memberDeclarations = memberDeclarations;
         this.constructors = constructors;
         this.primaryConstructor = primaryConstructor;
-        this.isInner = isInner;
-        return this;
     }
 
     public void setPrimaryConstructor(@NotNull ConstructorDescriptor primaryConstructor) {
         this.primaryConstructor = primaryConstructor;
     }
 
-    public void setClassObjectDescriptor(@NotNull ClassDescriptor classObjectDescriptor) {
+    @NotNull
-        this.classObjectDescriptor = classObjectDescriptor;
+    @Override
+    public List<AnnotationDescriptor> getAnnotations() {
+        return Collections.emptyList();
     }
 
     @Override
@@ -95,24 +90,6 @@ public class ClassDescriptorImpl extends DeclarationDescriptorNonRootImpl implem
         return typeConstructor;
     }
 
-    @Override
-    @NotNull
-    public JetScope getMemberScope(List<? extends TypeProjection> typeArguments) {
-        assert typeArguments.size() == typeConstructor.getParameters().size() : "Wrong number or arguments: " + typeArguments + " for " + this;
-        if (typeConstructor.getParameters().isEmpty()) {
-            return  memberDeclarations;
-        }
-        Map<TypeConstructor, TypeProjection> substitutionContext = SubstitutionUtils
-                .buildSubstitutionContext(typeConstructor.getParameters(), typeArguments);
-        return new SubstitutingScope(memberDeclarations, TypeSubstitutor.create(substitutionContext));
-    }
-
-    @NotNull
-    @Override
-    public JetType getDefaultType() {
-        return TypeUtils.makeUnsubstitutedType(this, memberDeclarations);
-    }
-
     @NotNull
     @Override
     public Collection<ConstructorDescriptor> getConstructors() {
@@ -121,29 +98,20 @@ public class ClassDescriptorImpl extends DeclarationDescriptorNonRootImpl implem
 
     @NotNull
     @Override
-    public ClassDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
+    protected JetScope getScopeForMemberLookup() {
-        throw new UnsupportedOperationException(); // TODO
+        return scopeForMemberLookup;
-    }
-
-    @Override
-    public JetType getClassObjectType() {
-        return getClassObjectDescriptor().getDefaultType();
     }
 
+    @Nullable
     @Override
     public ClassDescriptor getClassObjectDescriptor() {
-        return classObjectDescriptor;
+        return null;
     }
 
     @NotNull
     @Override
     public ClassKind getKind() {
-        return kind;
+        return ClassKind.CLASS;
-    }
-
-    @Override
-    public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
-        return visitor.visitClassDescriptor(this, data);
     }
 
     @Override
@@ -165,21 +133,17 @@ public class ClassDescriptorImpl extends DeclarationDescriptorNonRootImpl implem
 
     @Override
     public boolean isInner() {
-        return isInner;
+        return false;
     }
 
     @NotNull
     @Override
     public ReceiverParameterDescriptor getThisAsReceiverParameter() {
-        if (thisAsReceiverParameter == null) {
+        return thisAsReceiverParameter.invoke();
-            thisAsReceiverParameter = DescriptorFactory.createLazyReceiverParameterDescriptor(this);
-        }
-        return thisAsReceiverParameter;
     }
 
-    @NotNull
     @Override
-    public JetScope getUnsubstitutedInnerClassesScope() {
+    public String toString() {
-        return JetScope.EMPTY;
+        return "class " + getName();
     }
 }

core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -22,7 +22,6 @@ import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.ImportPath;
@@ -255,24 +254,6 @@ public class ErrorUtils {
 
     private static final ErrorClassDescriptor ERROR_CLASS = new ErrorClassDescriptor("");
 
-    private static final Set<ConstructorDescriptor> ERROR_CONSTRUCTOR_GROUP = Collections.singleton(createErrorConstructor());
-
-    private static final ConstructorDescriptor ERROR_CONSTRUCTOR = new ConstructorDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), true);
-
-    static {
-        ERROR_CLASS.initializeErrorClass();
-    }
-
-    @NotNull
-    public static Set<ConstructorDescriptor> getErrorConstructorGroup() {
-        return ERROR_CONSTRUCTOR_GROUP;
-    }
-
-    @NotNull
-    public static ConstructorDescriptor getErrorConstructor() {
-        return ERROR_CONSTRUCTOR;
-    }
-
     @NotNull
     public static JetScope createErrorScope(@NotNull String debugMessage) {
         return createErrorScope(debugMessage, false);
@@ -316,18 +297,6 @@ public class ErrorUtils {
         return function;
     }
 
-    @NotNull
-    private static ConstructorDescriptor createErrorConstructor() {
-        ConstructorDescriptorImpl r = new ConstructorDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), false);
-        r.initialize(
-                Collections.<TypeParameterDescriptor>emptyList(), // TODO
-                Collections.<ValueParameterDescriptor>emptyList(), // TODO
-                Visibilities.INTERNAL
-        );
-        r.setReturnType(createErrorType("<ERROR RETURN TYPE>"));
-        return r;
-    }
-
     @NotNull
     public static JetType createErrorType(@NotNull String debugMessage) {
         return new ErrorTypeImpl(createErrorTypeConstructor(debugMessage), createErrorScope(debugMessage));
@@ -373,13 +342,6 @@ public class ErrorUtils {
         return candidate instanceof ErrorClassDescriptor;
     }
 
-    @NotNull
-    public static ErrorClassDescriptor createErrorClass(@NotNull String debugMessage) {
-        ErrorClassDescriptor result = new ErrorClassDescriptor(debugMessage);
-        result.initializeErrorClass();
-        return result;
-    }
-
     private static class ErrorTypeImpl implements JetType {
         private final TypeConstructor constructor;
         private final JetScope memberScope;

core/descriptors/src/org/jetbrains/jet/lang/types/error/ErrorClassDescriptor.java

@@ -17,38 +17,33 @@
 package org.jetbrains.jet.lang.types.error;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
-import org.jetbrains.jet.lang.descriptors.Modality;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
-import java.util.Collection;
 import java.util.Collections;
 
 import static org.jetbrains.jet.lang.types.ErrorUtils.*;
 
 public final class ErrorClassDescriptor extends ClassDescriptorImpl {
     public ErrorClassDescriptor(@NotNull String debugMessage) {
-        super(ErrorUtils.getErrorModule(), Collections.<AnnotationDescriptor>emptyList(), Modality.OPEN,
+        super(getErrorModule(), Name.special("<ERROR CLASS: " + debugMessage + ">"), Modality.OPEN, Collections.<JetType>emptyList());
-              Name.special("<ERROR CLASS: " + debugMessage + ">"));
-    }
 
-    @NotNull
+        ConstructorDescriptorImpl errorConstructor =
-    @Override
+                new ConstructorDescriptorImpl(this, Collections.<AnnotationDescriptor>emptyList(), true);
-    public Collection<ConstructorDescriptor> getConstructors() {
-        return getErrorConstructorGroup();
-    }
 
-    @NotNull
+        errorConstructor.initialize(
-    @Override
+                Collections.<TypeParameterDescriptor>emptyList(), // TODO
-    public Modality getModality() {
+                Collections.<ValueParameterDescriptor>emptyList(), // TODO
-        return Modality.OPEN;
+                Visibilities.INTERNAL
+        );
+        errorConstructor.setReturnType(createErrorType("<ERROR RETURN TYPE>"));
+
+        initialize(createErrorScope("ERROR_CLASS"), Collections.<ConstructorDescriptor>singleton(errorConstructor), errorConstructor);
     }
 
     @NotNull
@@ -61,9 +56,4 @@ public final class ErrorClassDescriptor extends ClassDescriptorImpl {
     public String toString() {
         return getName().asString();
     }
-
-    public void initializeErrorClass() {
-        initialize(true, Collections.<TypeParameterDescriptor>emptyList(), Collections.<JetType>emptyList(),
-                   createErrorScope("ERROR_CLASS"), getErrorConstructorGroup(), getErrorConstructor(), false);
-    }
 }