diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java b/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java
index 414d8c456a6..34e6d8f4879 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java
+++ b/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) {
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
index 683c922eab2..8e4b4de7fe6 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+++ b/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) {
-            namedMembers.functionDescriptors = Collections.emptySet();
-            return;
-        }
-
-        Set<FunctionDescriptor> functionDescriptors = new HashSet<FunctionDescriptor>(namedMembers.methods.size());
+        Set<NamedFunctionDescriptor> functionsFromCurrent = Sets.newHashSet();
         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;
-        if (scopeData instanceof ResolverBinaryClassData) {
-            substitutorForGenericSupertypes = createSubstitutorForGenericSupertypes(((ResolverBinaryClassData) scopeData).classDescriptor);
-        } else {
-            substitutorForGenericSupertypes = TypeSubstitutor.EMPTY;
-        }
+        TypeSubstitutor substitutorForGenericSupertypes = typeSubstitutorForGenericSupertypes(scopeData);
 
         List<FunctionDescriptor> functions = new ArrayList<FunctionDescriptor>();
-        
-        for (NamedMembers namedMembers : scopeData.namedMembersMap.values()) {
-            resolveNamedGroupFunctions(containingDeclaration, psiClass, substitutorForGenericSupertypes, namedMembers);
+
+        for (Map.Entry<String, NamedMembers> entry : scopeData.namedMembersMap.entrySet()) {
+            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
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java
index 8fca96e6029..5312df706de 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java
+++ b/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()) {
-                    if (field.isStatic() != staticMembers) {
-                        continue;
-                    }
-
-                    if (field.isPrivate()) {
+                for (PsiField field0 : psiClass.getPsiClass().getFields()) {
+                    PsiFieldWrapper field = new PsiFieldWrapper(field0);
+                    
+                    if (!includeMember(field)) {
                         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 (method.isStatic() != staticMembers) {
-                    continue;
-                }
-
-                if (method.isPrivate()) {
+                if (!includeMember(method)) {
                     continue;
                 }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
index ca50d5462ef..0f1ac47a803 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
+++ b/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
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java
index 23914fc429f..c52862bae8a 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java
+++ b/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);
     }
     
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PropertyAccessorData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PropertyAccessorData.java
index 8be7adfe85f..d2cdb52024b 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PropertyAccessorData.java
+++ b/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
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassWrapper.java
index 87c60326709..eb8ad1fb6c7 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassWrapper.java
+++ b/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() {
-        if (methods == null) {
+    public List<PsiMethodWrapper> getOwnMethods() {
+        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() {
-        if (fields == null) {
+    public List<PsiFieldWrapper> getOwnFields() {
+        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() {
diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiMemberWrapper.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiMemberWrapper.java
index 9bb7dbb5694..16337969c30 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiMemberWrapper.java
+++ b/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);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java
index d22f7684274..7754aa2400d 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java
+++ b/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();
     }
diff --git a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java
index 4610b62d740..6abd1bd31ce 100644
--- a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java
+++ b/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");
         }
diff --git a/testlib/test/regressions/kt1202.kt b/testlib/test/regressions/kt1202.kt
index e158681e0ac..48b3f735e55 100644
--- a/testlib/test/regressions/kt1202.kt
+++ b/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