Include subpackages and fake overrides into allDescriptors

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java

@@ -44,7 +44,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
     private final Map<Name, Set<FunctionDescriptor>> functionDescriptors = Maps.newHashMap();
     private final Map<Name, Set<VariableDescriptor>> propertyDescriptors = Maps.newHashMap();
 
-    private final List<DeclarationDescriptor> allDescriptors = Lists.newArrayList();
+    protected final List<DeclarationDescriptor> allDescriptors = Lists.newArrayList();
 
     protected AbstractLazyMemberScope(
             @NotNull ResolveSession resolveSession,
@@ -200,10 +200,13 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
                 throw new IllegalArgumentException("Unsupported declaration kind: " + declaration);
             }
         }
+        addExtraDescriptors();
         allDescriptorsComputed = true;
         return allDescriptors;
     }
 
+    protected abstract void addExtraDescriptors();
+
     @Override
     public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         ReceiverDescriptor receiver = getImplicitReceiver();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/FileBasedDeclarationProviderFactory.java

@@ -16,10 +16,8 @@
 
 package org.jetbrains.jet.lang.resolve.lazy;
 
-import com.google.common.collect.HashMultimap;
+import com.google.common.base.Predicate;
-import com.google.common.collect.Maps;
+import com.google.common.collect.*;
-import com.google.common.collect.Multimap;
-import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -38,7 +36,7 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF
     private final Collection<JetFile> allFiles;
 
     private final Multimap<FqName, JetFile> filesByPackage = HashMultimap.create();
-    private final Set<FqName> definedPackages = Sets.newHashSet();
+    private final Set<FqName> declaredPackages = Sets.newHashSet();
     private final Map<FqName, PackageMemberDeclarationProvider> packageDeclarationProviders = Maps.newHashMap();
     private final Map<JetClassOrObject, ClassMemberDeclarationProvider> classMemberDeclarationProviders = Maps.newHashMap();
 
@@ -65,7 +63,7 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF
     }
 
     private void addMeAndParentPackages(@NotNull FqName name) {
-        definedPackages.add(name);
+        declaredPackages.add(name);
         if (!name.isRoot()) {
             addMeAndParentPackages(name.parent());
         }
@@ -73,7 +71,16 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF
 
     /*package*/ boolean isPackageDeclared(@NotNull FqName packageFqName) {
         createIndex();
-        return definedPackages.contains(packageFqName);
+        return declaredPackages.contains(packageFqName);
+    }
+
+    /*package*/ Collection<FqName> getAllDeclaredSubPackagesOf(@NotNull final FqName parent) {
+        return Collections2.filter(declaredPackages, new Predicate<FqName>() {
+            @Override
+            public boolean apply(FqName fqName) {
+                return !fqName.isRoot() && fqName.parent().equals(parent);
+            }
+        });
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/FileBasedPackageMemberDeclarationProvider.java

@@ -31,6 +31,7 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD
     private final FqName fqName;
     private final FileBasedDeclarationProviderFactory factory;
     private final Collection<JetFile> allFiles;
+    private Collection<FqName> allDeclaredPackages;
 
 
     /*package*/ FileBasedPackageMemberDeclarationProvider(
@@ -56,4 +57,12 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD
     public boolean isPackageDeclared(@NotNull Name name) {
         return factory.isPackageDeclared(fqName.child(name));
     }
+
+    @Override
+    public Collection<FqName> getAllDeclaredPackages() {
+        if (allDeclaredPackages == null) {
+            allDeclaredPackages = factory.getAllDeclaredSubPackagesOf(fqName);
+        }
+        return allDeclaredPackages;
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java

@@ -75,7 +75,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
                     @Override
                     public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
                         assert fakeOverride instanceof FunctionDescriptor : "A non-function overrides a function";
-                        result.add((FunctionDescriptor) fakeOverride);
+                        FunctionDescriptor functionDescriptor = (FunctionDescriptor) fakeOverride;
+                        result.add(functionDescriptor);
+                        allDescriptors.add(functionDescriptor);
                     }
 
                     @Override
@@ -100,6 +102,21 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         throw new UnsupportedOperationException(); // TODO
     }
 
+    @Override
+    protected void addExtraDescriptors() {
+        for (JetType supertype : thisDescriptor.getTypeConstructor().getSupertypes()) {
+            for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) {
+                if (descriptor instanceof FunctionDescriptor) {
+                    getFunctions(descriptor.getName());
+                }
+                else if (descriptor instanceof PropertyDescriptor) {
+                    getProperties(descriptor.getName());
+                }
+                // Nothing else is inherited
+            }
+        }
+    }
+
     @Override
     public NamespaceDescriptor getNamespace(@NotNull Name name) {
         return null;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
@@ -58,6 +59,7 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
         NamespaceDescriptor namespaceDescriptor = new LazyPackageDescriptor(thisDescriptor, name, resolveSession, packageMemberDeclarationProvider);
 
         packageDescriptors.put(name, namespaceDescriptor);
+        allDescriptors.add(namespaceDescriptor);
 
         return namespaceDescriptor;
     }
@@ -84,4 +86,11 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
     protected void getNonDeclaredProperties(@NotNull Name name, @NotNull Set<VariableDescriptor> result) {
         // No extra properties
     }
+
+    @Override
+    protected void addExtraDescriptors() {
+        for (FqName packageFqName : declarationProvider.getAllDeclaredPackages()) {
+            getNamespace(packageFqName.shortName());
+        }
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/PackageMemberDeclarationProvider.java

@@ -17,12 +17,17 @@
 package org.jetbrains.jet.lang.resolve.lazy;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import java.util.Collection;
+
 /**
  * @author abreslav
  */
 public interface PackageMemberDeclarationProvider extends DeclarationProvider {
 
     boolean isPackageDeclared(@NotNull Name name);
+
+    Collection<FqName> getAllDeclaredPackages();
 }

compiler/tests/org/jetbrains/jet/cli/jvm/compiler/NamespaceComparator.java

@@ -94,6 +94,19 @@ public class NamespaceComparator {
             else if (ad instanceof FunctionDescriptor) {
                 functionNames.add(ad.getName());
             }
+            else if (ad instanceof NamespaceDescriptor) {
+                NamespaceDescriptor namespaceDescriptorA = (NamespaceDescriptor) ad;
+                NamespaceDescriptor namespaceDescriptorB = nsb.getMemberScope().getNamespace(namespaceDescriptorA.getName());
+                //Assert.assertNotNull("Namespace not found: " + namespaceDescriptorA.getQualifiedName(), namespaceDescriptorB);
+                if (namespaceDescriptorB == null) {
+                    System.err.println("Namespace not found: " + namespaceDescriptorA.getQualifiedName());
+                }
+                else {
+                    sb.append("// <namespace name=\"" + namespaceDescriptorA.getName() + "\">\n");
+                    sb.append(doCompareNamespaces(namespaceDescriptorA, namespaceDescriptorB));
+                    sb.append("// </namespace name=\"" + namespaceDescriptorA.getName() + "\">\n");
+                }
+            }
             else {
                 throw new AssertionError("unknown member: " + ad);
             }