Get rid of dependency of class descriptors on BindingTrace

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

@@ -24,7 +24,9 @@ import org.jetbrains.jet.descriptors.serialization.*;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
+import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.TraceUtil;
 import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullable;
 import org.jetbrains.jet.lang.resolve.lazy.storage.NotNullLazyValue;
 import org.jetbrains.jet.lang.resolve.lazy.storage.NullableLazyValue;
@@ -36,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.*;
 
@@ -282,14 +285,14 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
         classObject.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classObject.createTypeConstructor();
 
-        // TODO: do something if trace has errors?
-        BindingTrace trace = new BindingTraceContext();
         ConstructorDescriptorImpl primaryConstructor = DescriptorResolver.createPrimaryConstructorForObject(classObject);
         primaryConstructor.setReturnType(classObject.getDefaultType());
-        classObject.setPrimaryConstructor(primaryConstructor, trace);
+        classObject.setPrimaryConstructor(primaryConstructor);
 
-        classObject.getBuilder().addFunctionDescriptor(DescriptorResolver.createEnumClassObjectValuesMethod(classObject, trace));
+        JetType defaultType = getDefaultType();
-        classObject.getBuilder().addFunctionDescriptor(DescriptorResolver.createEnumClassObjectValueOfMethod(classObject, trace));
+        JetType defaultTypeArray = KotlinBuiltIns.getInstance().getArrayType(defaultType);
+        classObject.getBuilder().addFunctionDescriptor(DescriptorResolver.createEnumClassObjectValuesMethod(classObject, defaultTypeArray));
+        classObject.getBuilder().addFunctionDescriptor(DescriptorResolver.createEnumClassObjectValueOfMethod(classObject, defaultType));
 
         return classObject;
     }

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptor.java

@@ -20,12 +20,10 @@ import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.psi.JetParameter;
-import org.jetbrains.jet.lang.resolve.BindingContextUtils;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.*;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 
@@ -65,32 +63,26 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite {
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-    public void addConstructor(@NotNull ConstructorDescriptor constructorDescriptor, @NotNull BindingTrace trace) {
+    public void setPrimaryConstructor(@NotNull ConstructorDescriptor constructorDescriptor) {
-        if (constructorDescriptor.getContainingDeclaration() != this) {
+        assert primaryConstructor == null : "Primary constructor assigned twice " + this;
-            throw new IllegalStateException("invalid containing declaration of constructor");
+        primaryConstructor = constructorDescriptor;
-        }
+
         constructors.add(constructorDescriptor);
+
         if (defaultType != null) {
             ((ConstructorDescriptorImpl) constructorDescriptor).setReturnType(getDefaultType());
         }
 
-        boolean primary = constructorDescriptor.isPrimary();
+        if (constructorDescriptor.isPrimary()) {
-        if (primary) {
             setUpScopeForInitializers(constructorDescriptor);
-            for (ValueParameterDescriptor valueParameterDescriptor : constructorDescriptor.getValueParameters()) {
-                JetParameter parameter = (JetParameter) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), valueParameterDescriptor);
-                assert parameter != null;
-                if (parameter.getValOrVarNode() == null) {
-                    getWritableScopeForInitializers().addVariableDescriptor(valueParameterDescriptor);
-                }
-            }
         }
     }
 
-    public void setPrimaryConstructor(@NotNull ConstructorDescriptor constructorDescriptor, BindingTrace trace) {
+    public void addConstructorParametersToInitializersScope(@NotNull Collection<? extends VariableDescriptor> variables) {
-        assert this.primaryConstructor == null : "Primary constructor assigned twice " + this;
+        WritableScope scope = getWritableScopeForInitializers();
-        this.primaryConstructor = constructorDescriptor;
+        for (VariableDescriptor variable : variables) {
-        addConstructor(constructorDescriptor, trace);
+            scope.addVariableDescriptor(variable);
+        }
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java

@@ -298,6 +298,7 @@ public class DeclarationResolver {
             List<ValueParameterDescriptor> valueParameterDescriptors = constructorDescriptor.getValueParameters();
             List<JetParameter> primaryConstructorParameters = klass.getPrimaryConstructorParameters();
             assert valueParameterDescriptors.size() == primaryConstructorParameters.size();
+            List<ValueParameterDescriptor> notProperties = new ArrayList<ValueParameterDescriptor>();
             for (ValueParameterDescriptor valueParameterDescriptor : valueParameterDescriptors) {
                 JetParameter parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex());
                 if (parameter.getValOrVarNode() != null) {
@@ -310,9 +311,14 @@ public class DeclarationResolver {
                     classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
                     context.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor);
                 }
+                else {
+                    notProperties.add(valueParameterDescriptor);
+                }
             }
+
             if (classDescriptor.getKind() != ClassKind.TRAIT) {
-                classDescriptor.setPrimaryConstructor(constructorDescriptor, trace);
+                classDescriptor.setPrimaryConstructor(constructorDescriptor);
+                classDescriptor.addConstructorParametersToInitializersScope(notProperties);
             }
         }
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java

@@ -28,7 +28,10 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.SubstitutionUtils;
 import org.jetbrains.jet.lang.types.TypeConstructor;
@@ -612,7 +615,7 @@ public class TypeHierarchyResolver {
         ) {
             ConstructorDescriptorImpl constructorDescriptor = DescriptorResolver
                     .createAndRecordPrimaryConstructorForObject(object, mutableClassDescriptor, trace);
-            mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor, trace);
+            mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor);
             return constructorDescriptor;
         }