Important JavaDescriptorResolver refactoring

This patch implement own member filling with supertype scope. Before this patch JDR relied on
Idea hierarchy resolver.

This patch does two things:

* copies FunctionDescriptors from supertype scopes
* rewrites containingDeclaration similary to how it is done in previous patch

Patch is incomplete, in particular properties are not yet initialized properly, code needs cleanup,
however the most important part of refactoring is done, and tests pass.

compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java

@@ -94,7 +94,7 @@ public class CallableMethod implements Callable {
     }
 
     void invoke(InstructionAdapter v) {
-        v.visitMethodInsn(getInvokeOpcode(), getOwner(), getSignature().getAsmMethod().getName(), getSignature().getAsmMethod().getDescriptor());
+        v.visitMethodInsn(getInvokeOpcode(), owner, getSignature().getAsmMethod().getName(), getSignature().getAsmMethod().getDescriptor());
     }
 
     public void requestGenerateCallee(Type objectType) {

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

@@ -33,6 +33,8 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.resolve.java.alt.AltClassFinder;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
 import org.jetbrains.jet.lang.types.*;
@@ -81,7 +83,7 @@ public class JavaDescriptorResolver {
         JAVA,
         KOTLIN,
     }
-    
+
     public static class TypeParameterDescriptorInitialization {
         @NotNull
         private final TypeParameterDescriptorOrigin origin;
@@ -170,7 +172,7 @@ public class JavaDescriptorResolver {
     protected final Map<String, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
     protected final Map<PsiElement, ResolverNamespaceData> namespaceDescriptorCache = Maps.newHashMap();
 
-    protected final Map<PsiMethod, FunctionDescriptor> methodDescriptorCache = Maps.newHashMap();
+    protected final Map<PsiMethod, FunctionDescriptorImpl> methodDescriptorCache = Maps.newHashMap();
     protected final JavaPsiFacade javaFacade;
     protected final GlobalSearchScope javaSearchScope;
     protected final JavaSemanticServices semanticServices;
@@ -394,11 +396,29 @@ public class JavaDescriptorResolver {
             }
         }
 
+        // TODO
+        //classData.classDescriptor.setClassObjectDescriptor(createClassObjectDescriptor(classData.classDescriptor));
+
         semanticServices.getTrace().record(BindingContext.CLASS, psiClass, classData.classDescriptor);
 
         return classData;
     }
 
+    /**
+     * TODO
+     * @see #createJavaNamespaceDescriptor(com.intellij.psi.PsiClass)
+     */
+    @Nullable
+    private MutableClassDescriptorLite createClassObjectDescriptor(@NotNull ClassDescriptor containing, @NotNull PsiClass psiClass) {
+        MutableClassDescriptorLite classObjectDescriptor = new MutableClassDescriptorLite(containing, ClassKind.OBJECT);
+        classObjectDescriptor.setName("<TODO>"); // TODO
+        classObjectDescriptor.setModality(Modality.FINAL);
+        classObjectDescriptor.setTypeParameterDescriptors(new ArrayList<TypeParameterDescriptor>(0));
+        classObjectDescriptor.createTypeConstructor();
+        classObjectDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classObjectDescriptor, psiClass, semanticServices, true));
+        return classObjectDescriptor;
+    }
+
     private List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData, TypeVariableByNameResolver typeVariableByNameResolver) {
         JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
         classData.kotlin = jetClassAnnotation.isDefined();
@@ -767,6 +787,10 @@ public class JavaDescriptorResolver {
         return resolveNamespace(parentPackage);
     }
 
+    /**
+     * TODO
+     * @see #createClassObjectDescriptor(org.jetbrains.jet.lang.descriptors.ClassDescriptor, com.intellij.psi.PsiClass)
+     */
     private ResolverNamespaceData createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) {
         ResolverNamespaceData namespaceData = new ResolverNamespaceData();
         namespaceData.namespaceDescriptor = new JavaNamespaceDescriptor(
@@ -791,30 +815,6 @@ public class JavaDescriptorResolver {
         }
     }
 
-    private ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration,
-            List<PsiParameterWrapper> parameters, TypeVariableResolver typeVariableResolver) {
-        List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
-        JetType receiverType = null;
-        int indexDelta = 0;
-        for (int i = 0, parametersLength = parameters.size(); i < parametersLength; i++) {
-            PsiParameterWrapper parameter = parameters.get(i);
-            JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i + indexDelta, parameter, typeVariableResolver);
-            if (meaning.kind == JvmMethodParameterKind.TYPE_INFO) {
-                // TODO
-                --indexDelta;
-            } else if (meaning.kind == JvmMethodParameterKind.REGULAR) {
-                result.add(meaning.valueParameterDescriptor);
-            } else if (meaning.kind == JvmMethodParameterKind.RECEIVER) {
-                if (receiverType != null) {
-                    throw new IllegalStateException("more then one receiver");
-                }
-                --indexDelta;
-                receiverType = meaning.receiverType;
-            }
-        }
-        return new ValueParameterDescriptors(receiverType, result);
-    }
-
     private enum JvmMethodParameterKind {
         REGULAR,
         RECEIVER,
@@ -907,10 +907,17 @@ public class JavaDescriptorResolver {
         if (namedMembers == null) {
             return Collections.emptySet();
         }
+        Set<VariableDescriptor> r = new HashSet<VariableDescriptor>();
 
         resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, fieldName);
 
-        return namedMembers.propertyDescriptors;
+        r.addAll(namedMembers.propertyDescriptors);
+
+        for (JetType supertype : getSupertypes(scopeData)) {
+            r.addAll(supertype.getMemberScope().getProperties(fieldName));
+        }
+
+        return r;
     }
     
     @NotNull
@@ -931,6 +938,16 @@ public class JavaDescriptorResolver {
             resolveNamedGroupProperties(owner, scopeData, staticMembers, namedMembers, propertyName);
             descriptors.addAll(namedMembers.propertyDescriptors);
         }
+
+        for (JetType supertype : getSupertypes(scopeData)) {
+            for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) {
+                // TODO: ugly
+                if (descriptor instanceof VariableDescriptor) {
+                    descriptors.add((VariableDescriptor) descriptor);
+                }
+            }
+        }
+        
         return descriptors;
     }
     
@@ -1140,24 +1157,50 @@ public class JavaDescriptorResolver {
         namedMembers.propertyDescriptors = r;
     }
 
-    private void resolveNamedGroupFunctions(ClassOrNamespaceDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, NamedMembers namedMembers) {
+    private void resolveNamedGroupFunctions(ClassOrNamespaceDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, NamedMembers namedMembers, String methodName, ResolverScopeData scopeData) {
         if (namedMembers.functionDescriptors != null) {
             return;
         }
+        
+        final Set<FunctionDescriptor> functions = new HashSet<FunctionDescriptor>();
 
-        if (namedMembers.methods == null) {
+        Set<NamedFunctionDescriptor> functionsFromCurrent = Sets.newHashSet();
-            namedMembers.functionDescriptors = Collections.emptySet();
-            return;
-        }
-
-        Set<FunctionDescriptor> functionDescriptors = new HashSet<FunctionDescriptor>(namedMembers.methods.size());
         for (PsiMethodWrapper method : namedMembers.methods) {
-            FunctionDescriptor function = resolveMethodToFunctionDescriptor(owner, psiClass, typeSubstitutorForGenericSuperclasses, method);
+            FunctionDescriptorImpl function = resolveMethodToFunctionDescriptor(owner, psiClass,
+                    typeSubstitutorForGenericSuperclasses,
+                    method);
             if (function != null) {
-                functionDescriptors.add(function);
+                functionsFromCurrent.add((NamedFunctionDescriptor) function);
             }
         }
-        namedMembers.functionDescriptors = functionDescriptors;
+
+        if (owner instanceof ClassDescriptor) {
+            ClassDescriptor classDescriptor = (ClassDescriptor) owner;
+
+            Set<NamedFunctionDescriptor> functionsFromSupertypes = getFunctionsFromSupertypes(scopeData, methodName);
+
+            OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink<NamedFunctionDescriptor>() {
+                @Override
+                public void addToScope(NamedFunctionDescriptor fakeOverride) {
+                    functions.add(fakeOverride);
+                }
+            });
+
+        }
+
+        functions.addAll(functionsFromCurrent);
+
+        namedMembers.functionDescriptors = functions;
+    }
+    
+    private Set<NamedFunctionDescriptor> getFunctionsFromSupertypes(ResolverScopeData scopeData, String methodName) {
+        Set<NamedFunctionDescriptor> r = new HashSet<NamedFunctionDescriptor>();
+        for (JetType supertype : getSupertypes(scopeData)) {
+            for (FunctionDescriptor function : supertype.getMemberScope().getFunctions(methodName)) {
+                r.add((NamedFunctionDescriptor) function);
+            }
+        }
+        return r;
     }
 
     private ResolverScopeData getResolverScopeData(@NotNull ClassOrNamespaceDescriptor owner, PsiClassWrapper psiClass) {
@@ -1191,19 +1234,15 @@ public class JavaDescriptorResolver {
         Map<String, NamedMembers> namedMembersMap = resolverScopeData.namedMembersMap;
 
         NamedMembers namedMembers = namedMembersMap.get(methodName);
-        if (namedMembers == null || namedMembers.methods == null) {
+        if (namedMembers != null && namedMembers.methods != null) {
+            TypeSubstitutor typeSubstitutor = typeSubstitutorForGenericSupertypes(resolverScopeData);
+
+            resolveNamedGroupFunctions(descriptor, psiClass, typeSubstitutor, namedMembers, methodName, resolverScopeData);
+
+            return namedMembers.functionDescriptors;
+        } else {
             return Collections.emptySet();
         }
-
-        TypeSubstitutor typeSubstitutor;
-        if (descriptor instanceof ClassDescriptor && !staticMembers) {
-            typeSubstitutor = createSubstitutorForGenericSupertypes((ClassDescriptor) descriptor);
-        } else {
-            typeSubstitutor = TypeSubstitutor.EMPTY;
-        }
-        resolveNamedGroupFunctions(descriptor, psiClass, typeSubstitutor, namedMembers);
-        
-        return namedMembers.functionDescriptors;
     }
 
     private TypeSubstitutor createSubstitutorForGenericSupertypes(@Nullable ClassDescriptor classDescriptor) {
@@ -1274,17 +1313,42 @@ public class JavaDescriptorResolver {
         return equal(p1.getOwner(), p2.getOwner());
     }
 
+    private ValueParameterDescriptors resolveParameterDescriptors(DeclarationDescriptor containingDeclaration,
+            List<PsiParameterWrapper> parameters, TypeVariableResolver typeVariableResolver) {
+        List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
+        JetType receiverType = null;
+        int indexDelta = 0;
+        for (int i = 0, parametersLength = parameters.size(); i < parametersLength; i++) {
+            PsiParameterWrapper parameter = parameters.get(i);
+            JvmMethodParameterMeaning meaning = resolveParameterDescriptor(containingDeclaration, i + indexDelta, parameter, typeVariableResolver);
+            if (meaning.kind == JvmMethodParameterKind.TYPE_INFO) {
+                // TODO
+                --indexDelta;
+            } else if (meaning.kind == JvmMethodParameterKind.REGULAR) {
+                result.add(meaning.valueParameterDescriptor);
+            } else if (meaning.kind == JvmMethodParameterKind.RECEIVER) {
+                if (receiverType != null) {
+                    throw new IllegalStateException("more then one receiver");
+                }
+                --indexDelta;
+                receiverType = meaning.receiverType;
+            }
+        }
+        return new ValueParameterDescriptors(receiverType, result);
+    }
+
     @Nullable
-    private FunctionDescriptor resolveMethodToFunctionDescriptor(ClassOrNamespaceDescriptor owner, final PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, final PsiMethodWrapper method) {
+    private FunctionDescriptorImpl resolveMethodToFunctionDescriptor(ClassOrNamespaceDescriptor owner, final PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, final PsiMethodWrapper method) {
-        
+
         PsiType returnType = method.getReturnType();
         if (returnType == null) {
             return null;
         }
-        FunctionDescriptor functionDescriptor = methodDescriptorCache.get(method.getPsiMethod());
+        FunctionDescriptorImpl functionDescriptor = methodDescriptorCache.get(method.getPsiMethod());
         if (functionDescriptor != null) {
             if (method.getPsiMethod().getContainingClass() != psiClass) {
-                functionDescriptor = functionDescriptor.substitute(typeSubstitutorForGenericSuperclasses);
+                //functionDescriptor = functionDescriptor.substitute(typeSubstitutorForGenericSuperclasses);
+                throw new IllegalStateException();
             }
             return functionDescriptor;
         }
@@ -1434,36 +1498,52 @@ public class JavaDescriptorResolver {
         semanticServices.getTrace().record(BindingContext.FUNCTION, method.getPsiMethod(), functionDescriptorImpl);
         FunctionDescriptor substitutedFunctionDescriptor = functionDescriptorImpl;
         if (method.getPsiMethod().getContainingClass() != psiClass) {
-            substitutedFunctionDescriptor = functionDescriptorImpl.substitute(typeSubstitutorForGenericSuperclasses);
+            //substitutedFunctionDescriptor = functionDescriptorImpl.substitute(typeSubstitutorForGenericSuperclasses);
+            throw new IllegalStateException();
         }
-        return substitutedFunctionDescriptor;
+        return (FunctionDescriptorImpl) substitutedFunctionDescriptor;
     }
-    
+
     public List<FunctionDescriptor> resolveMethods(PsiClass psiClass, ClassOrNamespaceDescriptor containingDeclaration) {
         ResolverScopeData scopeData = getResolverScopeData(containingDeclaration, new PsiClassWrapper(psiClass));
 
-        TypeSubstitutor substitutorForGenericSupertypes;
+        TypeSubstitutor substitutorForGenericSupertypes = typeSubstitutorForGenericSupertypes(scopeData);
-        if (scopeData instanceof ResolverBinaryClassData) {
-            substitutorForGenericSupertypes = createSubstitutorForGenericSupertypes(((ResolverBinaryClassData) scopeData).classDescriptor);
-        } else {
-            substitutorForGenericSupertypes = TypeSubstitutor.EMPTY;
-        }
 
         List<FunctionDescriptor> functions = new ArrayList<FunctionDescriptor>();
-        
+
-        for (NamedMembers namedMembers : scopeData.namedMembersMap.values()) {
+        for (Map.Entry<String, NamedMembers> entry : scopeData.namedMembersMap.entrySet()) {
-            resolveNamedGroupFunctions(containingDeclaration, psiClass, substitutorForGenericSupertypes, namedMembers);
+            String methodName = entry.getKey();
+            NamedMembers namedMembers = entry.getValue();
+            resolveNamedGroupFunctions(containingDeclaration, psiClass, substitutorForGenericSupertypes, namedMembers, methodName, scopeData);
             functions.addAll(namedMembers.functionDescriptors);
         }
 
         return functions;
     }
 
+    private Collection<JetType> getSupertypes(ResolverScopeData scope) {
+        if (scope instanceof ResolverBinaryClassData) {
+            return ((ResolverBinaryClassData) scope).classDescriptor.getSupertypes();
+        } else if (scope instanceof ResolverNamespaceData) {
+            return Collections.emptyList();
+        } else {
+            throw new IllegalStateException();
+        }
+    }
+
+    private TypeSubstitutor typeSubstitutorForGenericSupertypes(ResolverScopeData scopeData) {
+        if (scopeData instanceof ResolverClassData) {
+            return createSubstitutorForGenericSupertypes(((ResolverClassData) scopeData).getClassDescriptor());
+        } else {
+            return TypeSubstitutor.EMPTY;
+        }
+    }
+
     private List<TypeParameterDescriptorInitialization> resolveMethodTypeParameters(
             @NotNull PsiMethodWrapper method,
             @NotNull DeclarationDescriptor functionDescriptor,
-            @NotNull TypeVariableResolver classTypeVariableResolver
+            @NotNull TypeVariableResolver classTypeVariableResolver) {
-    ) {
+
         List<TypeParameterDescriptorInitialization> typeParameters;
         if (method.getJetMethod().typeParameters().length() > 0) {
             typeParameters = resolveMethodTypeParametersFromJetSignature(
@@ -1477,13 +1557,13 @@ public class JavaDescriptorResolver {
     }
 
     /**
-     * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, MutableClassDescriptorLite)
+     * @see #resolveClassTypeParametersFromJetSignature(String, com.intellij.psi.PsiClass, org.jetbrains.jet.lang.descriptors.ClassDescriptor, TypeVariableResolver)
      */
     private List<TypeParameterDescriptorInitialization> resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method,
             final DeclarationDescriptor functionDescriptor, final TypeVariableByNameResolver classTypeVariableByNameResolver)
     {
         final List<TypeParameterDescriptorInitialization> r = new ArrayList<TypeParameterDescriptorInitialization>();
-        
+
         class MyTypeVariableByNameResolver implements TypeVariableByNameResolver {
 
             @NotNull

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

@@ -17,10 +17,14 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.psi.HierarchicalMethodSignature;
+import com.intellij.psi.PsiField;
+import com.intellij.psi.PsiMember;
+import com.intellij.psi.PsiMethod;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -57,14 +61,28 @@ class JavaDescriptorResolverHelper {
             return r;
         }
         
+        private boolean includeMember(PsiMemberWrapper member) {
+            if (member.isStatic() != staticMembers) {
+                return false;
+            }
+
+            if (!staticMembers && member.getPsiMember().getContainingClass() != psiClass.getPsiClass()) {
+                return false;
+            }
+            
+            if (member.isPrivate()) {
+                return false;
+            }
+
+            return true;
+        }
+        
         private void processFields() {
             if (!kotlin) {
-                for (PsiFieldWrapper field : psiClass.getFields()) {
+                for (PsiField field0 : psiClass.getPsiClass().getFields()) {
-                    if (field.isStatic() != staticMembers) {
+                    PsiFieldWrapper field = new PsiFieldWrapper(field0);
-                        continue;
+                    
-                    }
+                    if (!includeMember(field)) {
-
-                    if (field.isPrivate()) {
                         continue;
                     }
 
@@ -77,15 +95,16 @@ class JavaDescriptorResolverHelper {
         }
 
         private void processMethods() {
-            for (HierarchicalMethodSignature method0 : psiClass.getPsiClass().getVisibleSignatures()) {
+            
+            for (PsiMethod method : psiClass.getPsiClass().getAllMethods()) {
+                getNamedMembers(method.getName());
+            }
+
+            
+            for (PsiMethod method0 : psiClass.getPsiClass().getMethods()) {
+                PsiMethodWrapper method = new PsiMethodWrapper(method0);
                 
-                PsiMethodWrapper method = new PsiMethodWrapper(method0.getMethod());
+                if (!includeMember(method)) {
-
-                if (method.isStatic() != staticMembers) {
-                    continue;
-                }
-
-                if (method.isPrivate()) {
                     continue;
                 }
 

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

@@ -139,7 +139,7 @@ public class JavaTypeTransformer {
                         for (int i = 0; i < parameters.size(); i++) {
                             PsiType psiArgument = psiArguments[i];
                             TypeParameterDescriptor typeParameterDescriptor = parameters.get(i);
-                            
+
                             TypeVariableResolver typeVariableByPsiResolver2 = new TypeVariableResolver() {
                                 @NotNull
                                 @Override

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

@@ -30,7 +30,7 @@ import java.util.Set;
 */
 class NamedMembers {
     String name;
-    List<PsiMethodWrapper> methods;
+    List<PsiMethodWrapper> methods = new ArrayList<PsiMethodWrapper>(0);
 
     @Nullable
     PsiFieldWrapper field;
@@ -41,12 +41,10 @@ class NamedMembers {
     private PsiClass nestedClasses;
     
     Set<VariableDescriptor> propertyDescriptors;
+    /** Including from supertypes */
     Set<FunctionDescriptor> functionDescriptors;
 
     void addMethod(PsiMethodWrapper method) {
-        if (methods == null) {
-            methods = new ArrayList<PsiMethodWrapper>();
-        }
         methods.add(method);
     }
     

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.intellij.psi.HierarchicalMethodSignature;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -26,6 +27,8 @@ class PropertyAccessorData {
 
     @NotNull
     private final PsiMemberWrapper member;
+
+    // for methods
     private final boolean getter;
 
     @NotNull

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

@@ -37,32 +37,36 @@ public class PsiClassWrapper {
         this.psiClass = psiClass;
     }
     
-    private List<PsiMethodWrapper> methods;
+    private List<PsiMethodWrapper> ownMethods;
     @NotNull
-    public List<PsiMethodWrapper> getMethods() {
+    public List<PsiMethodWrapper> getOwnMethods() {
-        if (methods == null) {
+        if (ownMethods == null) {
             PsiMethod[] psiMethods = psiClass.getMethods();
             List<PsiMethodWrapper> methods = new ArrayList<PsiMethodWrapper>(psiMethods.length);
             for (PsiMethod psiMethod : psiMethods) {
+                if (psiMethod.getContainingClass() != psiClass)
+                    continue;
                 methods.add(new PsiMethodWrapper(psiMethod));
             }
-            this.methods = methods;
+            this.ownMethods = methods;
         }
-        return methods;
+        return ownMethods;
     }
     
-    private List<PsiFieldWrapper> fields;
+    private List<PsiFieldWrapper> ownFields;
     @NotNull
-    public List<PsiFieldWrapper> getFields() {
+    public List<PsiFieldWrapper> getOwnFields() {
-        if (fields == null) {
+        if (ownFields == null) {
             PsiField[] psiFields = psiClass.getFields();
             List<PsiFieldWrapper> fields = new ArrayList<PsiFieldWrapper>(psiFields.length);
             for (PsiField psiField : psiFields) {
+                if (psiField.getContainingClass() != psiClass)
+                    continue;
                 fields.add(new PsiFieldWrapper(psiField));
             }
-            this.fields = fields;
+            this.ownFields = fields;
         }
-        return fields;
+        return ownFields;
     }
     
     public String getQualifiedName() {

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

@@ -32,6 +32,11 @@ public abstract class PsiMemberWrapper {
         this.psiMember = psiMember;
     }
 
+    @NotNull
+    public PsiMember getPsiMember() {
+        return psiMember;
+    }
+
     public boolean isStatic() {
         return psiMember.hasModifierProperty(PsiModifier.STATIC);
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java

@@ -22,6 +22,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassKind;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
@@ -109,7 +111,7 @@ public class OverloadingConflictResolver {
                 return false;
             }
         }
-
+        
         if (discriminateGenericDescriptors && isGeneric(f)) {
             if (!isGeneric(g)) {
                 return false;
@@ -122,7 +124,7 @@ public class OverloadingConflictResolver {
 
         return true;
     }
-
+    
     private boolean isGeneric(CallableDescriptor f) {
         return !f.getOriginal().getTypeParameters().isEmpty();
     }

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

@@ -18,7 +18,19 @@ package org.jetbrains.jet.compiler;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.PropertyCodegen;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassKind;
+import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
+import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.Modality;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaNamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -32,7 +44,12 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.StringReader;
 import java.lang.reflect.Method;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 /**
  * @author Stepan Koltsov
@@ -166,8 +183,11 @@ class NamespaceComparator {
                 case TRAIT:
                     sb.append("trait");
                     break;
+                case OBJECT:
+                    sb.append("object");
+                    break;
                 default:
-                    throw new IllegalStateException();
+                    throw new IllegalStateException("unknown class kind: " + kind);
             }
         }
 
@@ -184,6 +204,10 @@ class NamespaceComparator {
         public void serialize(FunctionDescriptor fun) {
             serialize(fun.getModality());
             sb.append(" ");
+            
+            if (!fun.getOverriddenDescriptors().isEmpty()) {
+                sb.append("override /*" + fun.getOverriddenDescriptors().size() + "*/ ");
+            }
 
             if (fun instanceof ConstructorDescriptor) {
                 sb.append("/*constructor*/ ");
@@ -473,6 +497,12 @@ class NamespaceComparator {
             for (String memberString : memberStrings) {
                 sb.append(indent(memberString));
             }
+            
+            if (klass.getClassObjectDescriptor() != null) {
+                StringBuilder sbForClassObject = new StringBuilder();
+                new FullContentSerialier(sbForClassObject).serialize(klass.getClassObjectDescriptor());
+                sb.append(indent(sbForClassObject.toString()));
+            }
 
             sb.append("}\n");
         }

testlib/test/regressions/kt1202.kt

@@ -2,6 +2,7 @@ package testeval
 
 import java.util.*
 import junit.framework.TestCase.*
+import junit.framework.Assert.* // TODO unnecessary import
 
 trait Expression
 class Num(val value : Int) : Expression