Support properties in serialized classes

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

@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.Modality;
 import org.jetbrains.jet.lang.descriptors.Visibility;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
@@ -88,13 +89,38 @@ public class DescriptorDeserializer {
                 return loadFunction(proto);
             case VAL:
             case VAR:
-                break;
+                return loadProperty(proto);
             case CONSTRUCTOR:
                 break;
         }
         throw new IllegalArgumentException("Unsupported callable kind: " + callableKind);
     }
 
+    @NotNull
+    private PropertyDescriptor loadProperty(@NotNull Callable proto) {
+        int flags = proto.getFlags();
+        PropertyDescriptorImpl property = new PropertyDescriptorImpl(
+                containingDeclaration,
+                // TODO: annotations
+                Collections.<AnnotationDescriptor>emptyList(),
+                modality(Flags.getModality(flags)),
+                visibility(Flags.getVisibility(flags)),
+                Flags.getCallableKind(flags) == Callable.CallableKind.VAR,
+                nameResolver.getName(proto.getName()),
+                memberKind(Flags.getMemberKind(flags))
+        );
+        DescriptorDeserializer local = new DescriptorDeserializer(this, property, nameResolver);
+        List<TypeParameterDescriptor> typeParameters = local.typeParameters(proto.getTypeParametersList());
+        property.setType(
+                local.typeDeserializer.type(proto.getReturnType()),
+                typeParameters,
+                // TODO: expected this object
+                null,
+                local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null)
+        );
+        return property;
+    }
+
     @NotNull
     private CallableMemberDescriptor loadFunction(@NotNull Callable proto) {
         int flags = proto.getFlags();
@@ -106,11 +132,12 @@ public class DescriptorDeserializer {
                 memberKind(Flags.getMemberKind(flags))
         );
         DescriptorDeserializer local = new DescriptorDeserializer(this, function, nameResolver);
+        List<TypeParameterDescriptor> typeParameters = local.typeParameters(proto.getTypeParametersList());
         function.initialize(
                 local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null),
                 // TODO: expectedThisObject
                 null,
-                local.typeParameters(proto.getTypeParametersList()),
+                typeParameters,
                 local.valueParameters(proto.getValueParametersList()),
                 local.typeDeserializer.type(proto.getReturnType()),
                 modality(Flags.getModality(flags)),

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

@@ -78,10 +78,10 @@ public class DescriptorSerializer {
 
         for (DeclarationDescriptor descriptor : classDescriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
             // TODO: other than functions
-            if (descriptor instanceof FunctionDescriptor) {
+            if (descriptor instanceof CallableMemberDescriptor) {
-                FunctionDescriptor function = (FunctionDescriptor) descriptor;
+                CallableMemberDescriptor member = (CallableMemberDescriptor) descriptor;
-                if (function.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) continue;
+                if (member.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) continue;
-                builder.addMembers(local.functionProto(function));
+                builder.addMembers(local.callableProto(member));
             }
         }
 
@@ -89,15 +89,16 @@ public class DescriptorSerializer {
     }
 
     @NotNull
-    public ProtoBuf.Callable.Builder functionProto(@NotNull FunctionDescriptor function) {
+    public ProtoBuf.Callable.Builder callableProto(@NotNull CallableMemberDescriptor descriptor) {
         ProtoBuf.Callable.Builder builder = ProtoBuf.Callable.newBuilder();
 
         // TODO setter flags
-        builder.setFlags(Flags.getCallableFlags(function.getVisibility(),
+        builder.setFlags(Flags.getCallableFlags(descriptor.getVisibility(),
-                                                function.getModality(),
+                                                descriptor.getModality(),
-                                                function.getKind(),
+                                                descriptor.getKind(),
-                                                callableKind(function),
+                                                callableKind(descriptor),
-                                                function instanceof SimpleFunctionDescriptor && ((SimpleFunctionDescriptor) function).isInline())
+                                                descriptor instanceof SimpleFunctionDescriptor &&
+                                                ((SimpleFunctionDescriptor) descriptor).isInline())
         );
         //TODO builder.setExtraVisibility()
 
@@ -105,22 +106,22 @@ public class DescriptorSerializer {
 
         DescriptorSerializer local = this;//createChildSerializer();
 
-        for (TypeParameterDescriptor typeParameterDescriptor : function.getTypeParameters()) {
+        for (TypeParameterDescriptor typeParameterDescriptor : descriptor.getTypeParameters()) {
             builder.addTypeParameters(local.typeParameter(typeParameterDescriptor));
         }
 
-        ReceiverParameterDescriptor receiverParameter = function.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
         if (receiverParameter != null) {
             builder.setReceiverType(local.type(receiverParameter.getType()));
         }
 
-        builder.setName(nameTable.getSimpleNameIndex(function.getName()));
+        builder.setName(nameTable.getSimpleNameIndex(descriptor.getName()));
 
-        for (ValueParameterDescriptor valueParameterDescriptor : function.getValueParameters()) {
+        for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) {
             builder.addValueParameters(local.valueParameter(valueParameterDescriptor));
         }
 
-        builder.setReturnType(local.type(function.getReturnType()));
+        builder.setReturnType(local.type(descriptor.getReturnType()));
 
         return builder;
     }

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

@@ -31,10 +31,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
 
 public class DeserializedClassDescriptor extends ClassDescriptorBase implements ClassDescriptor {
 
@@ -227,7 +224,7 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
 
         @Override
         protected void computeNonDeclaredFunctions(
-                @NotNull Name name, @NotNull List<FunctionDescriptor> functions
+                @NotNull Name name, @NotNull Collection<FunctionDescriptor> functions
         ) {
             Collection<FunctionDescriptor> fromSupertypes = new ArrayList<FunctionDescriptor>();
             for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
@@ -236,6 +233,18 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
             generateFakeOverrides(name, fromSupertypes, functions);
         }
 
+        @Override
+        protected void computeNonDeclaredProperties(
+                @NotNull Name name, @NotNull Collection<PropertyDescriptor> property
+        ) {
+            Collection<PropertyDescriptor> fromSupertypes = new ArrayList<PropertyDescriptor>();
+            for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
+                //noinspection unchecked
+                fromSupertypes.addAll((Collection) supertype.getMemberScope().getProperties(name));
+            }
+            generateFakeOverrides(name, fromSupertypes, property);
+        }
+
         private <D extends CallableMemberDescriptor> void generateFakeOverrides(
                 @NotNull Name name,
                 @NotNull Collection<D> fromSupertypes,

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

@@ -34,6 +34,19 @@ import java.util.*;
 
 public abstract class DeserializedMemberScope implements JetScope {
 
+    private static final Filter<ProtoBuf.Callable.CallableKind> FUNCTION = new Filter<ProtoBuf.Callable.CallableKind>() {
+        @Override
+        public boolean accept(ProtoBuf.Callable.CallableKind value) {
+            return value == ProtoBuf.Callable.CallableKind.FUN;
+        }
+    };
+    private static final Filter<ProtoBuf.Callable.CallableKind> PROPERTY = new Filter<ProtoBuf.Callable.CallableKind>() {
+        @Override
+        public boolean accept(ProtoBuf.Callable.CallableKind value) {
+            return value == ProtoBuf.Callable.CallableKind.VAL || value == ProtoBuf.Callable.CallableKind.VAR;
+        }
+    };
+
     private final DeclarationDescriptor containingDeclaration;
     private final DescriptorDeserializer deserializer;
     private final Map<Name, List<ProtoBuf.Callable>> membersProtos;
@@ -90,13 +103,13 @@ public abstract class DeserializedMemberScope implements JetScope {
     }
 
     @NotNull
-    private <D extends CallableMemberDescriptor> List<D> computeMembersByName(Name name, ProtoBuf.Callable.CallableKind callableKind) {
+    private <D extends CallableMemberDescriptor> Collection<D> computeMembersByName(Name name, Filter<ProtoBuf.Callable.CallableKind> callableKind) {
         List<ProtoBuf.Callable> memberProtos = membersProtos.get(name);
 
-        List<D> descriptors = new ArrayList<D>(memberProtos != null ? memberProtos.size() : 0);
+        Collection<D> descriptors = new LinkedHashSet<D>(memberProtos != null ? memberProtos.size() : 0);
         if (memberProtos != null) {
             for (ProtoBuf.Callable memberProto : memberProtos) {
-                if (Flags.getCallableKind(memberProto.getFlags()) == callableKind) {
+                if (callableKind.accept(Flags.getCallableKind(memberProto.getFlags()))) {
                     //noinspection unchecked
                     descriptors.add((D) deserializer.loadCallable(memberProto));
                 }
@@ -107,13 +120,12 @@ public abstract class DeserializedMemberScope implements JetScope {
 
     @NotNull
     private Collection<FunctionDescriptor> computeFunctions(@NotNull Name name) {
-        List<FunctionDescriptor> descriptors = computeMembersByName(name, ProtoBuf.Callable.CallableKind.FUN);
+        Collection<FunctionDescriptor> descriptors = computeMembersByName(name, FUNCTION);
         computeNonDeclaredFunctions(name, descriptors);
         return descriptors;
     }
 
-    protected void computeNonDeclaredFunctions(@NotNull Name name, @NotNull List<FunctionDescriptor> functions) {
+    protected void computeNonDeclaredFunctions(@NotNull Name name, @NotNull Collection<FunctionDescriptor> functions) {
-
     }
 
     @NotNull
@@ -124,7 +136,13 @@ public abstract class DeserializedMemberScope implements JetScope {
 
     @NotNull
     private Collection<VariableDescriptor> computeProperties(@NotNull Name name) {
-        return Collections.emptyList(); // TODO
+        Collection<PropertyDescriptor> descriptors = computeMembersByName(name, PROPERTY);
+        computeNonDeclaredProperties(name, descriptors);
+        //noinspection unchecked
+        return (Collection) descriptors;
+    }
+
+    protected void computeNonDeclaredProperties(@NotNull Name name, @NotNull Collection<PropertyDescriptor> descriptors) {
     }
 
     @NotNull
@@ -221,4 +239,8 @@ public abstract class DeserializedMemberScope implements JetScope {
         return getAllDescriptors();
     }
 
+    private interface Filter<T> {
+        boolean accept(T value);
+    }
+
 }