Support fake overrides

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

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase;
 import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.TraceUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
@@ -223,33 +224,34 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
             this.classDescriptor = classDescriptor;
         }
 
-        @NotNull
         @Override
-        public Collection<FunctionDescriptor> getFunctions(@NotNull Name name) {
+        protected void computeNonDeclaredFunctions(
+                @NotNull Name name, @NotNull List<FunctionDescriptor> functions
+        ) {
             Collection<FunctionDescriptor> fromSupertypes = new ArrayList<FunctionDescriptor>();
             for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
                 fromSupertypes.addAll(supertype.getMemberScope().getFunctions(name));
             }
-            Collection<FunctionDescriptor> result = super.getFunctions(name);
+            generateFakeOverrides(name, fromSupertypes, functions);
-            generateFakeOverrides(name, fromSupertypes, result);
-            return result;
         }
 
         private <D extends CallableMemberDescriptor> void generateFakeOverrides(
                 @NotNull Name name,
                 @NotNull Collection<D> fromSupertypes,
-                @NotNull final Collection<D> fromCurrent
+                @NotNull final Collection<D> result
         ) {
+            List<CallableMemberDescriptor> fromCurrent = new ArrayList<CallableMemberDescriptor>(result);
             OverrideResolver.generateOverridesInFunctionGroup(
                     name,
                     fromSupertypes,
-                    new ArrayList<CallableMemberDescriptor>(fromCurrent),
+                    fromCurrent,
                     classDescriptor,
                     new OverrideResolver.DescriptorSink() {
                         @Override
                         public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
+                            OverrideResolver.resolveUnknownVisibilityForMember(null, fakeOverride, TraceUtil.TRACE_STUB);
                             //noinspection unchecked
-                            fromCurrent.add((D) fakeOverride);
+                            result.add((D) fakeOverride);
                         }
 
                         @Override
@@ -260,6 +262,21 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
             );
         }
 
+        @Override
+        protected void addNonDeclaredDescriptors(@NotNull Collection<DeclarationDescriptor> result) {
+            for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
+                for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) {
+                    if (descriptor instanceof FunctionDescriptor) {
+                        result.addAll(getFunctions(descriptor.getName()));
+                    }
+                    else if (descriptor instanceof PropertyDescriptor) {
+                        result.addAll(getProperties(descriptor.getName()));
+                    }
+                    // Nothing else is inherited
+                }
+            }
+        }
+
         @Nullable
         @Override
         protected ClassifierDescriptor getClassDescriptor(@NotNull Name name) {

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

@@ -91,22 +91,27 @@ public abstract class DeserializedMemberScope implements JetScope {
     @NotNull
     private Collection<FunctionDescriptor> computeFunctions(@NotNull Name name) {
         List<ProtoBuf.Callable> functionProtos = membersProtos.get(name);
-        if (functionProtos == null || functionProtos.isEmpty()) {
+
-            return Collections.emptyList();
+        List<FunctionDescriptor> functions = new ArrayList<FunctionDescriptor>(functionProtos != null ? functionProtos.size() : 0);
+        if (functionProtos != null) {
+            for (ProtoBuf.Callable memberProto : functionProtos) {
+                // TODO: check that the proto is a function, and not a property
+                functions.add(deserializer.loadFunction(memberProto));
+            }
         }
 
-        List<FunctionDescriptor> functions = new ArrayList<FunctionDescriptor>(functionProtos.size());
+        computeNonDeclaredFunctions(name, functions);
-        for (ProtoBuf.Callable memberProto : functionProtos) {
-            // TODO: check that the proto is a function, and not a property
-            functions.add(deserializer.loadFunction(memberProto));
-        }
 
         return functions;
     }
 
+    protected void computeNonDeclaredFunctions(@NotNull Name name, @NotNull List<FunctionDescriptor> functions) {
+
+    }
+
     @NotNull
     @Override
-    public Collection<FunctionDescriptor> getFunctions(@NotNull Name name) {
+    public final Collection<FunctionDescriptor> getFunctions(@NotNull Name name) {
         return functions.fun(name);
     }
 
@@ -175,18 +180,22 @@ public abstract class DeserializedMemberScope implements JetScope {
     }
 
     private Collection<DeclarationDescriptor> computeAllDescriptors() {
-        Collection<DeclarationDescriptor> result = new ArrayList<DeclarationDescriptor>();
+        Collection<DeclarationDescriptor> result = new LinkedHashSet<DeclarationDescriptor>(0);
 
         for (Name name : membersProtos.keySet()) {
-            result.addAll(functions.fun(name));
+            result.addAll(getFunctions(name));
-            result.addAll(properties.fun(name));
+            result.addAll(getProperties(name));
         }
 
+        addNonDeclaredDescriptors(result);
+
         addAllClassDescriptors(result);
 
         return result;
     }
 
+    protected abstract void addNonDeclaredDescriptors(@NotNull Collection<DeclarationDescriptor> result);
+
     @NotNull
     @Override
     public final Collection<DeclarationDescriptor> getAllDescriptors() {