fix inner classes in JavaDescriptorResolver, kill type variable by psi resolver

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

@@ -34,7 +34,6 @@ 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.*;
@@ -118,12 +117,21 @@ public class JavaDescriptorResolver {
         protected boolean kotlin;
         
         private Map<String, NamedMembers> namedMembersMap;
+        
+        @NotNull
+        public abstract List<TypeParameterDescriptor> getTypeParameters();
     }
 
     static abstract class ResolverClassData extends ResolverScopeData {
 
         @NotNull
         public abstract ClassDescriptor getClassDescriptor();
+
+        @NotNull
+        @Override
+        public List<TypeParameterDescriptor> getTypeParameters() {
+            return getClassDescriptor().getTypeConstructor().getParameters();
+        }
     }
 
     /** Class with instance members */
@@ -166,6 +174,12 @@ public class JavaDescriptorResolver {
         public NamespaceDescriptor getNamespaceDescriptor() {
             return namespaceDescriptor;
         }
+
+        @NotNull
+        @Override
+        public List<TypeParameterDescriptor> getTypeParameters() {
+            return new ArrayList<TypeParameterDescriptor>(0);
+        }
     }
 
     protected final Map<String, ResolverBinaryClassData> classDescriptorCache = Maps.newHashMap();
@@ -257,23 +271,15 @@ public class JavaDescriptorResolver {
         String name = psiClass.getName();
         ResolverBinaryClassData classData = new ResolverBinaryClassData();
         ClassKind kind = psiClass.isInterface() ? (psiClass.isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT) : ClassKind.CLASS;
-        classData.classDescriptor = new MutableClassDescriptorLite(
+        DeclarationDescriptor containingDeclaration = resolveParentDescriptor(psiClass);
-                resolveParentDescriptor(psiClass), kind
+        classData.classDescriptor = new MutableClassDescriptorLite(containingDeclaration, kind);
-        );
         classData.classDescriptor.setName(name);
         
-        class OuterClassTypeVariableByNameResolver implements TypeVariableByNameResolver {
-
-            @NotNull
-            @Override
-            public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
-                throw new IllegalStateException("not implemented"); // TODO
-            }
-        }
-
         List<JetType> supertypes = new ArrayList<JetType>();
 
-        classData.typeParameters = createUninitializedClassTypeParameters(psiClass, classData, new OuterClassTypeVariableByNameResolver());
+        TypeVariableResolverFromOuters outerTypeVariableByNameResolver = new TypeVariableResolverFromOuters(containingDeclaration);
+
+        classData.typeParameters = createUninitializedClassTypeParameters(psiClass, classData, outerTypeVariableByNameResolver);
         
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>();
         for (TypeParameterDescriptorInitialization typeParameter : classData.typeParameters) {
@@ -291,12 +297,12 @@ public class JavaDescriptorResolver {
         classDescriptorCache.put(psiClass.getQualifiedName(), classData);
         classData.classDescriptor.setScopeForMemberLookup(new JavaClassMembersScope(classData.classDescriptor, psiClass, semanticServices, false));
 
-        initializeTypeParameters(classData.typeParameters, new TypeVariableResoverFromTypeDescriptorsInitialization(new ArrayList<TypeParameterDescriptorInitialization>(), null));
+        initializeTypeParameters(classData.typeParameters, new TypeVariableResolverFromTypeDescriptors(new ArrayList<TypeParameterDescriptor>(), outerTypeVariableByNameResolver));
 
-        TypeVariableResoverFromTypeDescriptorsInitialization resolverForTypeParameters = new TypeVariableResoverFromTypeDescriptorsInitialization(classData.typeParameters, null);
+        TypeVariableResolverFromTypeDescriptors resolverForTypeParameters = new TypeVariableResolverFromTypeDescriptors(classData.getTypeParameters(), null);
 
         // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
-        supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData.typeParameters));
+        supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData.getTypeParameters()));
 
         if (psiClass.isInterface()) {
             //classData.classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object
@@ -383,7 +389,7 @@ public class JavaDescriptorResolver {
                         false);
                 ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor,
                         constructor.getParameters(),
-                        new TypeVariableResoverFromTypeDescriptorsInitialization(classData.typeParameters, null) // TODO: outer too
+                        new TypeVariableResolverFromTypeDescriptors(classData.getTypeParameters(), null) // TODO: outer too
                     );
                 if (valueParameterDescriptors.receiverType != null) {
                     throw new IllegalStateException();
@@ -419,13 +425,13 @@ public class JavaDescriptorResolver {
         return classObjectDescriptor;
     }
 
-    private List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData, TypeVariableByNameResolver typeVariableByNameResolver) {
+    private List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData, TypeVariableResolver typeVariableResolver) {
         JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass);
         classData.kotlin = jetClassAnnotation.isDefined();
         
         if (jetClassAnnotation.signature().length() > 0) {
             return resolveClassTypeParametersFromJetSignature(
-                    jetClassAnnotation.signature(), psiClass, classData.classDescriptor, typeVariableByNameResolver);
+                    jetClassAnnotation.signature(), psiClass, classData.classDescriptor, typeVariableResolver);
         }
 
         return makeUninitializedTypeParameters(classData.classDescriptor, psiClass.getTypeParameters());
@@ -466,10 +472,10 @@ public class JavaDescriptorResolver {
         private final boolean reified;
         private final int index;
         private final TypeInfoVariance variance;
-        private final TypeVariableByNameResolver typeVariableByNameResolver;
+        private final TypeVariableResolver typeVariableResolver;
 
         protected JetSignatureTypeParameterVisitor(DeclarationDescriptor containingDeclaration, PsiTypeParameterListOwner psiOwner,
-                String name, boolean reified, int index, TypeInfoVariance variance, TypeVariableByNameResolver typeVariableByNameResolver)
+                String name, boolean reified, int index, TypeInfoVariance variance, TypeVariableResolver typeVariableResolver)
         {
             if (name.isEmpty()) {
                 throw new IllegalStateException();
@@ -481,7 +487,7 @@ public class JavaDescriptorResolver {
             this.reified = reified;
             this.index = index;
             this.variance = variance;
-            this.typeVariableByNameResolver = typeVariableByNameResolver;
+            this.typeVariableResolver = typeVariableResolver;
         }
 
         List<JetType> upperBounds = new ArrayList<JetType>();
@@ -489,7 +495,7 @@ public class JavaDescriptorResolver {
         
         @Override
         public JetSignatureVisitor visitClassBound() {
-            return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableByNameResolver) {
+            return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) {
                 @Override
                 protected void done(@NotNull JetType jetType) {
                     if (isJavaLangObject(jetType)) {
@@ -502,7 +508,7 @@ public class JavaDescriptorResolver {
 
         @Override
         public JetSignatureVisitor visitInterfaceBound() {
-            return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableByNameResolver) {
+            return new JetTypeJetSignatureReader(semanticServices, semanticServices.getJetSemanticServices().getStandardLibrary(), typeVariableResolver) {
                 @Override
                 protected void done(@NotNull JetType jetType) {
                     upperBounds.add(jetType);
@@ -531,10 +537,10 @@ public class JavaDescriptorResolver {
      * @see #resolveMethodTypeParametersFromJetSignature(String, FunctionDescriptor)
      */
     private List<TypeParameterDescriptorInitialization> resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz,
-            final ClassDescriptor classDescriptor, final TypeVariableByNameResolver outerClassTypeVariableByNameResolver) {
+            final ClassDescriptor classDescriptor, final TypeVariableResolver outerClassTypeVariableResolver) {
         final List<TypeParameterDescriptorInitialization> r = new ArrayList<TypeParameterDescriptorInitialization>();
         
-        class MyTypeVariableByNameResolver implements TypeVariableByNameResolver {
+        class MyTypeVariableResolver implements TypeVariableResolver {
 
             @NotNull
             @Override
@@ -544,7 +550,7 @@ public class JavaDescriptorResolver {
                         return typeParameter.descriptor;
                     }
                 }
-                return outerClassTypeVariableByNameResolver.getTypeVariable(name);
+                return outerClassTypeVariableResolver.getTypeVariable(name);
             }
         }
         
@@ -553,7 +559,7 @@ public class JavaDescriptorResolver {
             
             @Override
             public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance, boolean reified) {
-                return new JetSignatureTypeParameterVisitor(classDescriptor, clazz, name, reified, formalTypeParameterIndex++, variance, new MyTypeVariableByNameResolver()) {
+                return new JetSignatureTypeParameterVisitor(classDescriptor, clazz, name, reified, formalTypeParameterIndex++, variance, new MyTypeVariableResolver()) {
                     @Override
                     protected void done(TypeParameterDescriptorInitialization typeParameterDescriptor) {
                         r.add(typeParameterDescriptor);
@@ -609,7 +615,7 @@ public class JavaDescriptorResolver {
         return new TypeParameterDescriptorInitialization(typeParameterDescriptor, psiTypeParameter);
     }
 
-    private void initializeTypeParameter(TypeParameterDescriptorInitialization typeParameter, TypeVariableByPsiResolver typeVariableByPsiResolver) {
+    private void initializeTypeParameter(TypeParameterDescriptorInitialization typeParameter, TypeVariableResolver typeVariableByPsiResolver) {
         TypeParameterDescriptor typeParameterDescriptor = typeParameter.descriptor;
         if (typeParameter.origin == TypeParameterDescriptorOrigin.KOTLIN) {
             List<?> upperBounds = typeParameter.upperBoundsForKotlin;
@@ -640,18 +646,18 @@ public class JavaDescriptorResolver {
     }
 
     private void initializeTypeParameters(List<TypeParameterDescriptorInitialization> typeParametersInitialization, TypeVariableResolver typeVariableByPsiResolver) {
-        List<TypeParameterDescriptorInitialization> prevTypeParameters = new ArrayList<TypeParameterDescriptorInitialization>();
+        List<TypeParameterDescriptor> prevTypeParameters = new ArrayList<TypeParameterDescriptor>();
         for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
-            prevTypeParameters.add(psiTypeParameter);
+            prevTypeParameters.add(psiTypeParameter.descriptor);
-            initializeTypeParameter(psiTypeParameter, new TypeVariableResoverFromTypeDescriptorsInitialization(prevTypeParameters, typeVariableByPsiResolver));
+            initializeTypeParameter(psiTypeParameter, new TypeVariableResolverFromTypeDescriptors(prevTypeParameters, typeVariableByPsiResolver));
         }
     }
 
-    private Collection<? extends JetType> getSupertypes(PsiClassWrapper psiClass, List<TypeParameterDescriptorInitialization> typeParameters) {
+    private Collection<? extends JetType> getSupertypes(PsiClassWrapper psiClass, List<TypeParameterDescriptor> typeParameters) {
         final List<JetType> result = new ArrayList<JetType>();
 
         if (psiClass.getJetClass().signature().length() > 0) {
-            final TypeVariableResolver typeVariableResolver = new TypeVariableResoverFromTypeDescriptorsInitialization(typeParameters, null);
+            final TypeVariableResolver typeVariableResolver = new TypeVariableResolverFromTypeDescriptors(typeParameters, null);
             
             new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() {
                 @Override
@@ -685,8 +691,8 @@ public class JavaDescriptorResolver {
                 }
             });
         } else {
-            transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), new TypeVariableResoverFromTypeDescriptorsInitialization(typeParameters, null));
+            transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), new TypeVariableResolverFromTypeDescriptors(typeParameters, null));
-            transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), new TypeVariableResoverFromTypeDescriptorsInitialization(typeParameters, null));
+            transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), new TypeVariableResolverFromTypeDescriptors(typeParameters, null));
         }
         if (result.isEmpty()) {
             result.add(JetStandardClasses.getAnyType());
@@ -992,14 +998,9 @@ public class JavaDescriptorResolver {
             return;
         }
 
-        final List<TypeParameterDescriptorInitialization> classTypeParameterDescriptorInitialization;
+        final List<TypeParameterDescriptor> classTypeParameterDescriptorInitialization = scopeData.getTypeParameters();
-        if (scopeData instanceof ResolverBinaryClassData) {
-            classTypeParameterDescriptorInitialization = ((ResolverBinaryClassData) scopeData).typeParameters;
-        } else {
-            classTypeParameterDescriptorInitialization = new ArrayList<TypeParameterDescriptorInitialization>(0);
-        }
 
-        TypeVariableResolver typeVariableResolver = new TypeVariableResoverFromTypeDescriptorsInitialization(classTypeParameterDescriptorInitialization, null);
+        TypeVariableResolver typeVariableResolver = new TypeVariableResolverFromTypeDescriptors(scopeData.getTypeParameters(), null);
 
         class GroupingValue {
             PropertyAccessorData getter;
@@ -1093,7 +1094,7 @@ public class JavaDescriptorResolver {
 
             propertyDescriptor.initialize(getterDescriptor, setterDescriptor);
 
-            List<TypeParameterDescriptorInitialization> typeParametersInitialization = new ArrayList<TypeParameterDescriptorInitialization>(0);
+            List<TypeParameterDescriptor> typeParametersInitialization = new ArrayList<TypeParameterDescriptor>(0);
 
             if (members.setter != null) {
                 PsiMethodWrapper method = (PsiMethodWrapper) members.setter.getMember();
@@ -1111,14 +1112,14 @@ public class JavaDescriptorResolver {
             }
 
             List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>();
-            for (TypeParameterDescriptorInitialization typeParameter : typeParametersInitialization) {
+            for (TypeParameterDescriptor typeParameter : typeParametersInitialization) {
-                typeParameters.add(typeParameter.descriptor);
+                typeParameters.add(typeParameter);
             }
 
-            List<TypeParameterDescriptorInitialization> typeParametersForReceiver = new ArrayList<TypeParameterDescriptorInitialization>();
+            List<TypeParameterDescriptor> typeParametersForReceiver = new ArrayList<TypeParameterDescriptor>();
             typeParametersForReceiver.addAll(classTypeParameterDescriptorInitialization);
             typeParametersForReceiver.addAll(typeParametersInitialization);
-            TypeVariableResolver typeVariableResolverForPropertyInternals = new TypeVariableResoverFromTypeDescriptorsInitialization(typeParametersForReceiver, null);
+            TypeVariableResolver typeVariableResolverForPropertyInternals = new TypeVariableResolverFromTypeDescriptors(typeParametersForReceiver, null);
 
             JetType propertyType;
             if (anyMember.getType().getTypeString().length() > 0) {
@@ -1256,28 +1257,6 @@ public class JavaDescriptorResolver {
         return typeSubstitutor;
     }
     
-    // this method won't be necessary as soon as we resolve only local methods
-    private void getAllTypeParameterDescriptorInitialization(PsiClass psiClass, List<TypeParameterDescriptorInitialization> dest) {
-        ResolverClassData classData = resolveClassData(psiClass);
-
-        if (classData instanceof ResolverSrcClassData) {
-            // TODO hack
-            return;
-        }
-
-        ResolverBinaryClassData binaryClassData = (ResolverBinaryClassData) classData;
-        if (binaryClassData == null) {
-            return;
-        }
-        if (binaryClassData.typeParameters == null) {
-            throw new RuntimeException();
-        }
-        dest.addAll(binaryClassData.typeParameters);
-        for (PsiClass supr : psiClass.getSupers()) {
-            getAllTypeParameterDescriptorInitialization(supr, dest);
-        }
-    }
-    
     private static boolean equal(@NotNull PsiClass c1, @NotNull PsiClass c2) {
         return c1.getQualifiedName().equals(c2.getQualifiedName());
     }
@@ -1397,21 +1376,14 @@ public class JavaDescriptorResolver {
             }
         }
 
-        DeclarationDescriptor classDescriptor;
+        ClassOrNamespaceDescriptor classDescriptor;
-        final List<TypeParameterDescriptor> classTypeParameters;
+        final List<TypeParameterDescriptor> classTypeParameters = scopeData.getTypeParameters();
-        final List<TypeParameterDescriptorInitialization> classTypeParameterDescriptorsInitialization;
         if (scopeData instanceof ResolverBinaryClassData) {
             ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass());
             classDescriptor = classClassDescriptor;
-            classTypeParameters = classClassDescriptor.getTypeConstructor().getParameters();
-            classTypeParameterDescriptorsInitialization = new ArrayList<TypeParameterDescriptorInitialization>();
-            getAllTypeParameterDescriptorInitialization(psiClass, classTypeParameterDescriptorsInitialization);
-            //classTypeParameterDescriptorsInitialization = ((ResolverClassData) scopeData).typeParameters;
         }
         else {
             classDescriptor = resolveNamespace(method.getPsiMethod().getContainingClass());
-            classTypeParameters = new ArrayList<TypeParameterDescriptor>(0);
-            classTypeParameterDescriptorsInitialization = new ArrayList<TypeParameterDescriptorInitialization>(0);
         }
         if (classDescriptor == null) {
             return null;
@@ -1424,54 +1396,21 @@ public class JavaDescriptorResolver {
         );
         methodDescriptorCache.put(method.getPsiMethod(), functionDescriptorImpl);
 
-        // TODO: add outer classes
+        TypeVariableResolver typeVariableResolverForParameters = TypeVariableResolvers.classTypeVariableResolver(classDescriptor);
-        TypeVariableResolver typeVariableResolverForParameters = new TypeVariableResoverFromTypeDescriptorsInitialization(classTypeParameterDescriptorsInitialization, null);
 
-        final List<TypeParameterDescriptorInitialization> methodTypeParametersInitialization = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters);
+        final List<TypeParameterDescriptor> methodTypeParametersInitialization = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters);
         List<TypeParameterDescriptor> methodTypeParameters = new ArrayList<TypeParameterDescriptor>();
-        for (TypeParameterDescriptorInitialization typeParameterDescriptorInitialization : methodTypeParametersInitialization) {
+        for (TypeParameterDescriptor typeParameterDescriptorInitialization : methodTypeParametersInitialization) {
-            methodTypeParameters.add(typeParameterDescriptorInitialization.descriptor);
+            methodTypeParameters.add(typeParameterDescriptorInitialization);
         }
 
         class MethodTypeVariableResolver implements TypeVariableResolver {
-            @NotNull
-            @Override
-            public TypeParameterDescriptor getTypeVariable(@NotNull PsiTypeParameter psiTypeParameter) {
-                for (TypeParameterDescriptorInitialization typeParameter : methodTypeParametersInitialization) {
-                    if (equal(typeParameter.psiTypeParameter, psiTypeParameter)) {
-                        return typeParameter.descriptor;
-                    }
-                }
-                for (TypeParameterDescriptorInitialization typeParameter : classTypeParameterDescriptorsInitialization) {
-                    if (equal(typeParameter.psiTypeParameter, psiTypeParameter)) {
-                        return typeParameter.descriptor;
-                    }
-                }
-                throw new IllegalStateException("unresolved PsiTypeParameter " + psiTypeParameter.getName() + " in method " + method.getName() + " in class " + psiClass.getQualifiedName()); // TODO: report properly
-            }
-
-            @NotNull
-            @Override
-            public TypeParameterDescriptor getTypeVariableByPsiByName(@NotNull String name) {
-                for (TypeParameterDescriptorInitialization typeParameter : methodTypeParametersInitialization) {
-                    if (typeParameter.psiTypeParameter.getName().equals(name)) {
-                        return typeParameter.descriptor;
-                    }
-                }
-                for (TypeParameterDescriptorInitialization typeParameter : classTypeParameterDescriptorsInitialization) {
-                    if (typeParameter.psiTypeParameter.getName().equals(name)) {
-                        return typeParameter.descriptor;
-                    }
-                }
-                throw new IllegalStateException("unresolved PsiTypeParameter " + name + " in method " + method.getName() + " in class " + psiClass.getQualifiedName()); // TODO: report properly
-            }
-
             @NotNull
             @Override
             public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
-                for (TypeParameterDescriptorInitialization typeParameter : methodTypeParametersInitialization) {
+                for (TypeParameterDescriptor typeParameter : methodTypeParametersInitialization) {
-                    if (typeParameter.descriptor.getName().equals(name)) {
+                    if (typeParameter.getName().equals(name)) {
-                        return typeParameter.descriptor;
+                        return typeParameter;
                     }
                 }
                 for (TypeParameterDescriptor typeParameter : classTypeParameters) {
@@ -1539,20 +1478,27 @@ public class JavaDescriptorResolver {
         }
     }
 
-    private List<TypeParameterDescriptorInitialization> resolveMethodTypeParameters(
+    private List<TypeParameterDescriptor> resolveMethodTypeParameters(
             @NotNull PsiMethodWrapper method,
             @NotNull DeclarationDescriptor functionDescriptor,
             @NotNull TypeVariableResolver classTypeVariableResolver) {
 
-        List<TypeParameterDescriptorInitialization> typeParameters;
+        List<TypeParameterDescriptorInitialization> typeParametersIntialization;
         if (method.getJetMethod().typeParameters().length() > 0) {
-            typeParameters = resolveMethodTypeParametersFromJetSignature(
+            typeParametersIntialization = resolveMethodTypeParametersFromJetSignature(
                     method.getJetMethod().typeParameters(), method.getPsiMethod(), functionDescriptor, classTypeVariableResolver);
         } else {
-            typeParameters = makeUninitializedTypeParameters(functionDescriptor, method.getPsiMethod().getTypeParameters());
+            typeParametersIntialization = makeUninitializedTypeParameters(functionDescriptor, method.getPsiMethod().getTypeParameters());
+        }
+
+        initializeTypeParameters(typeParametersIntialization, classTypeVariableResolver);
+        
+        List<TypeParameterDescriptor> typeParameters = Lists.newArrayListWithCapacity(typeParametersIntialization.size());
+        
+        for (TypeParameterDescriptorInitialization tpdi : typeParametersIntialization) {
+            typeParameters.add(tpdi.descriptor);
         }
         
-        initializeTypeParameters(typeParameters, classTypeVariableResolver);
         return typeParameters;
     }
 
@@ -1560,11 +1506,11 @@ public class JavaDescriptorResolver {
      * @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 DeclarationDescriptor functionDescriptor, final TypeVariableResolver classTypeVariableResolver)
     {
         final List<TypeParameterDescriptorInitialization> r = new ArrayList<TypeParameterDescriptorInitialization>();
 
-        class MyTypeVariableByNameResolver implements TypeVariableByNameResolver {
+        class MyTypeVariableResolver implements TypeVariableResolver {
 
             @NotNull
             @Override
@@ -1574,7 +1520,7 @@ public class JavaDescriptorResolver {
                         return typeParameter.descriptor;
                     }
                 }
-                return classTypeVariableByNameResolver.getTypeVariable(name);
+                return classTypeVariableResolver.getTypeVariable(name);
             }
         }
         
@@ -1584,7 +1530,7 @@ public class JavaDescriptorResolver {
             @Override
             public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance, boolean reified) {
                 
-                return new JetSignatureTypeParameterVisitor(functionDescriptor, method, name, reified, formalTypeParameterIndex++, variance, new MyTypeVariableByNameResolver()) {
+                return new JetSignatureTypeParameterVisitor(functionDescriptor, method, name, reified, formalTypeParameterIndex++, variance, new MyTypeVariableResolver()) {
                     @Override
                     protected void done(TypeParameterDescriptorInitialization typeParameterDescriptor) {
                         r.add(typeParameterDescriptor);
@@ -1622,6 +1568,10 @@ public class JavaDescriptorResolver {
     }
 
     public List<ClassDescriptor> resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) {
+        if (staticMembers) {
+            return new ArrayList<ClassDescriptor>(0);
+        }
+
         PsiClass[] innerPsiClasses = psiClass.getInnerClasses();
         List<ClassDescriptor> r = new ArrayList<ClassDescriptor>(innerPsiClasses.length);
         for (PsiClass innerPsiClass : innerPsiClasses) {

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

@@ -51,7 +51,7 @@ public class JavaTypeTransformer {
     @NotNull
     public TypeProjection transformToTypeProjection(@NotNull final PsiType javaType,
             @NotNull final TypeParameterDescriptor typeParameterDescriptor,
-            @NotNull final TypeVariableByPsiResolver typeVariableByPsiResolver) {
+            @NotNull final TypeVariableResolver typeVariableByPsiResolver) {
         TypeProjection result = javaType.accept(new PsiTypeVisitor<TypeProjection>() {
 
             @Override
@@ -80,9 +80,9 @@ public class JavaTypeTransformer {
     }
 
     @NotNull
-    public JetType transformToType(@NotNull String kotlinSignature, TypeVariableByNameResolver typeVariableByNameResolver) {
+    public JetType transformToType(@NotNull String kotlinSignature, TypeVariableResolver typeVariableResolver) {
         final JetType[] r = new JetType[1];
-        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(javaSemanticServices, standardLibrary, typeVariableByNameResolver) {
+        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(javaSemanticServices, standardLibrary, typeVariableResolver) {
             @Override
             protected void done(@NotNull JetType jetType) {
                 r[0] = jetType;
@@ -94,7 +94,7 @@ public class JavaTypeTransformer {
 
     @NotNull
     public JetType transformToType(@NotNull PsiType javaType,
-            @NotNull final TypeVariableByPsiResolver typeVariableByPsiResolver) {
+            @NotNull final TypeVariableResolver typeVariableResolver) {
         return javaType.accept(new PsiTypeVisitor<JetType>() {
             @Override
             public JetType visitClassType(PsiClassType classType) {
@@ -106,7 +106,7 @@ public class JavaTypeTransformer {
 
                 if (psiClass instanceof PsiTypeParameter) {
                     PsiTypeParameter typeParameter = (PsiTypeParameter) psiClass;
-                    TypeParameterDescriptor typeParameterDescriptor = typeVariableByPsiResolver.getTypeVariable(typeParameter);
+                    TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName());
 //                    return TypeUtils.makeNullable(typeParameterDescriptor.getDefaultType());
                     return typeParameterDescriptor.getDefaultType();
                 }
@@ -144,39 +144,20 @@ public class JavaTypeTransformer {
                                 @NotNull
                                 @Override
                                 public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
-                                    throw new RuntimeException(); // TODO
-                                }
-
-                                @NotNull
-                                @Override
-                                public TypeParameterDescriptor getTypeVariable(@NotNull PsiTypeParameter psiTypeParameter) {
                                     if (classData instanceof JavaDescriptorResolver.ResolverSrcClassData) {
-                                        // hack for TypeInfoImpl
                                         for (TypeParameterDescriptor typeParameter : classData.getClassDescriptor().getTypeConstructor().getParameters()) {
-                                            if (psiTypeParameter.getName().equals(typeParameter.getName())) {
+                                            if (name.equals(typeParameter.getName())) {
                                                 // TODO?
                                                 return typeParameter;
                                             }
                                         }
-                                        return typeVariableByPsiResolver.getTypeVariableByPsiByName(psiTypeParameter.getName());
+                                        return typeVariableResolver.getTypeVariable(name);
                                     } else if (classData instanceof JavaDescriptorResolver.ResolverBinaryClassData) {
-                                        return new TypeVariableByPsiResolverImpl(((JavaDescriptorResolver.ResolverBinaryClassData) classData).typeParameters, typeVariableByPsiResolver).getTypeVariable(psiTypeParameter);
+                                        return typeVariableResolver.getTypeVariable(name);
                                     } else {
                                         throw new IllegalStateException();
                                     }
                                 }
-
-                                @NotNull
-                                @Override
-                                public TypeParameterDescriptor getTypeVariableByPsiByName(@NotNull String name) {
-                                    for (TypeParameterDescriptor typeParameter : classData.getClassDescriptor().getTypeConstructor().getParameters()) {
-                                        if (typeParameter.getName().equals(name)) {
-                                            // TODO?
-                                            return typeParameter;
-                                        }
-                                    }
-                                    throw new IllegalStateException();
-                                }
                             };
                             arguments.add(transformToTypeProjection(psiArgument, typeParameterDescriptor, typeVariableByPsiResolver2));
                         }
@@ -207,7 +188,7 @@ public class JavaTypeTransformer {
                         return TypeUtils.makeNullable(jetType);
                 }
 
-                JetType type = transformToType(componentType, typeVariableByPsiResolver);
+                JetType type = transformToType(componentType, typeVariableResolver);
                 return TypeUtils.makeNullable(standardLibrary.getArrayType(type));
             }
 

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

@@ -38,13 +38,13 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
     private final JavaSemanticServices javaSemanticServices;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final JetStandardLibrary jetStandardLibrary;
-    private final TypeVariableByNameResolver typeVariableByNameResolver;
+    private final TypeVariableResolver typeVariableResolver;
 
-    public JetTypeJetSignatureReader(JavaSemanticServices javaSemanticServices, JetStandardLibrary jetStandardLibrary, TypeVariableByNameResolver typeVariableByNameResolver) {
+    public JetTypeJetSignatureReader(JavaSemanticServices javaSemanticServices, JetStandardLibrary jetStandardLibrary, TypeVariableResolver typeVariableResolver) {
         this.javaSemanticServices = javaSemanticServices;
         this.javaDescriptorResolver = javaSemanticServices.getDescriptorResolver();
         this.jetStandardLibrary = jetStandardLibrary;
-        this.typeVariableByNameResolver = typeVariableByNameResolver;
+        this.typeVariableResolver = typeVariableResolver;
     }
     
     
@@ -132,7 +132,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public JetSignatureVisitor visitTypeArgument(final JetSignatureVariance variance) {
-        return new JetTypeJetSignatureReader(javaSemanticServices, jetStandardLibrary, typeVariableByNameResolver) {
+        return new JetTypeJetSignatureReader(javaSemanticServices, jetStandardLibrary, typeVariableResolver) {
 
             @Override
             protected void done(@NotNull JetType jetType) {
@@ -143,7 +143,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public JetSignatureVisitor visitArrayType(final boolean nullable) {
-        return new JetTypeJetSignatureReader(javaSemanticServices, jetStandardLibrary, typeVariableByNameResolver) {
+        return new JetTypeJetSignatureReader(javaSemanticServices, jetStandardLibrary, typeVariableResolver) {
             @Override
             public void visitBaseType(char descriptor, boolean nullable) {
                 JetType primitiveType = getPrimitiveType(descriptor, nullable);
@@ -166,7 +166,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
     @Override
     public void visitTypeVariable(String name, boolean nullable) {
-        JetType r = TypeUtils.makeNullableAsSpecified(typeVariableByNameResolver.getTypeVariable(name).getDefaultType(), nullable);
+        JetType r = TypeUtils.makeNullableAsSpecified(typeVariableResolver.getTypeVariable(name).getDefaultType(), nullable);
         done(r);
     }
 

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

@@ -1,30 +0,0 @@
-/*
- * Copyright 2010-2012 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.resolve.java;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-
-/**
- * @author Stepan Koltsov
- *
- * @see TypeVariableByPsiResolver
- */
-public interface TypeVariableByNameResolver {
-    @NotNull
-    TypeParameterDescriptor getTypeVariable(@NotNull String name);
-}

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

@@ -1,35 +0,0 @@
-/*
- * Copyright 2010-2012 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.resolve.java;
-
-import com.intellij.psi.PsiTypeParameter;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-
-/**
- * @author Stepan Koltsov
- *
- * @see TypeVariableByNameResolver
- */
-public interface TypeVariableByPsiResolver {
-    @NotNull
-    TypeParameterDescriptor getTypeVariable(@NotNull PsiTypeParameter psiTypeParameter);
-
-    /** @deprecated */
-    @NotNull
-    TypeParameterDescriptor getTypeVariableByPsiByName(@NotNull String name);
-}

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

@@ -1,68 +0,0 @@
-/*
- * Copyright 2010-2012 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.resolve.java;
-
-import com.intellij.psi.PsiTypeParameter;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-
-import java.util.List;
-
-/**
- * @author Stepan Koltsov
- */
-public class TypeVariableByPsiResolverImpl implements TypeVariableByPsiResolver {
-
-    @NotNull
-    private final List<JavaDescriptorResolver.TypeParameterDescriptorInitialization> typeParameters;
-    @Nullable
-    private final TypeVariableByPsiResolver parent;
-
-    public TypeVariableByPsiResolverImpl(@NotNull List<JavaDescriptorResolver.TypeParameterDescriptorInitialization> typeParameters, TypeVariableByPsiResolver parent) {
-        this.typeParameters = typeParameters;
-        this.parent = parent;
-    }
-
-    @NotNull
-    @Override
-    public TypeParameterDescriptor getTypeVariable(@NotNull PsiTypeParameter psiTypeParameter) {
-        for (JavaDescriptorResolver.TypeParameterDescriptorInitialization typeParameter : typeParameters) {
-            if (JavaDescriptorResolver.equal(typeParameter.psiTypeParameter, psiTypeParameter)) {
-                return typeParameter.descriptor;
-            }
-        }
-        if (parent != null) {
-            return parent.getTypeVariable(psiTypeParameter);
-        }
-        throw new RuntimeException("type parameter not found by PsiTypeParameter " + psiTypeParameter.getName()); // TODO report properly
-    }
-
-    @NotNull
-    @Override
-    public TypeParameterDescriptor getTypeVariableByPsiByName(@NotNull String name) {
-        for (JavaDescriptorResolver.TypeParameterDescriptorInitialization typeParameter : typeParameters) {
-            if (typeParameter.psiTypeParameter.getName().equals(name)) {
-                return typeParameter.descriptor;
-            }
-        }
-        if (parent != null) {
-            return parent.getTypeVariableByPsiByName(name);
-        }
-        throw new RuntimeException("type parameter not found by PsiTypeParameter " + name); // TODO report properly
-    }
-}

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

@@ -16,8 +16,13 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+
 /**
  * @author Stepan Koltsov
  */
-public interface TypeVariableResolver extends TypeVariableByPsiResolver, TypeVariableByNameResolver {
+public interface TypeVariableResolver {
+    @NotNull
+    TypeParameterDescriptor getTypeVariable(@NotNull String name);
 }

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2000-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class TypeVariableResolverFromOuters implements TypeVariableResolver {
+
+    @NotNull
+    private final DeclarationDescriptor outer;
+
+    public TypeVariableResolverFromOuters(@NotNull DeclarationDescriptor outer) {
+        this.outer = outer;
+    }
+
+    @NotNull
+    @Override
+    public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
+        DeclarationDescriptor outer = this.outer;
+        for (;;) {
+            if (outer instanceof NamespaceDescriptor) {
+                throw new IllegalStateException("unresolve type parameter: " + name);
+            } else if (outer instanceof ClassDescriptor) {
+                for (TypeParameterDescriptor typeParameter : ((ClassDescriptor) outer).getTypeConstructor().getParameters()) {
+                    if (typeParameter.getName().equals(name)) {
+                        return typeParameter;
+                    }
+                }
+                outer = outer.getContainingDeclaration();
+            } else {
+                throw new IllegalStateException("unknown outer: " + outer.getClass().getName());
+            }
+        }
+    }
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2012 JetBrains s.r.o.
+ * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,15 +25,14 @@ import java.util.List;
 /**
  * @author Stepan Koltsov
  */
-public class TypeVariableResoverFromTypeDescriptorsInitialization extends TypeVariableByPsiResolverImpl implements TypeVariableResolver {
+public class TypeVariableResolverFromTypeDescriptors implements TypeVariableResolver {
 
     @NotNull
-    private final List<JavaDescriptorResolver.TypeParameterDescriptorInitialization> typeParameters;
+    private final List<TypeParameterDescriptor> typeParameters;
     @Nullable
     private final TypeVariableResolver parent;
 
-    public TypeVariableResoverFromTypeDescriptorsInitialization(@NotNull List<JavaDescriptorResolver.TypeParameterDescriptorInitialization> typeParameters, @Nullable TypeVariableResolver parent) {
+    public TypeVariableResolverFromTypeDescriptors(@NotNull List<TypeParameterDescriptor> typeParameters, @Nullable TypeVariableResolver parent) {
-        super(typeParameters, parent);
         this.typeParameters = typeParameters;
         this.parent = parent;
     }
@@ -41,9 +40,9 @@ public class TypeVariableResoverFromTypeDescriptorsInitialization extends TypeVa
     @NotNull
     @Override
     public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
-        for (JavaDescriptorResolver.TypeParameterDescriptorInitialization typeParameter : typeParameters) {
+        for (TypeParameterDescriptor typeParameter : typeParameters) {
-            if (typeParameter.descriptor.getName().equals(name)) {
+            if (typeParameter.getName().equals(name)) {
-                return typeParameter.descriptor;
+                return typeParameter;
             }
         }
         if (parent != null) {

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2000-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java;
+
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+
+import java.util.ArrayList;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class TypeVariableResolvers {
+
+    public static TypeVariableResolver classTypeVariableResolver(ClassOrNamespaceDescriptor clazz) {
+        if (clazz instanceof ClassDescriptor) {
+            return new TypeVariableResolverFromTypeDescriptors(((ClassDescriptor) clazz).getTypeConstructor().getParameters(), new TypeVariableResolverFromOuters(clazz.getContainingDeclaration()));
+        } else {
+            return new TypeVariableResolverFromTypeDescriptors(new ArrayList<TypeParameterDescriptor>(0), null);
+        }
+    }
+    
+}

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.List;
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collections;
 import java.util.List;

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java

@@ -17,8 +17,10 @@
 package org.jetbrains.jet.lang.descriptors;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
@@ -112,7 +114,11 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
     @NotNull
     @Override
     public Set<ConstructorDescriptor> getConstructors() {
-        throw new UnsupportedOperationException(); // TODO
+        Set<ConstructorDescriptor> r = Sets.newHashSet();
+        for (ConstructorDescriptor constructor : original.getConstructors()) {
+            r.add((ConstructorDescriptor) constructor.substitute(getSubstitutor()));
+        }
+        return r;
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java

@@ -69,6 +69,12 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
         }
     }
     
+    protected void checkMayNotWrite() {
+        if (lockLevel == LockLevel.WRITING || lockLevel == LockLevel.BOTH) {
+            throw new IllegalStateException("cannot write with lock level " + lockLevel + " at " + debugName);
+        }
+    }
+
 
 
 

compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.java

@@ -0,0 +1,4 @@
+package test;
+
+abstract class ClassDoesNotOverrideMethod extends java.util.Date {
+}

compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.kt

@@ -0,0 +1,4 @@
+package test
+
+abstract class ClassDoesNotOverrideMethod() : java.util.Date() {
+}

compiler/testData/readJavaBinaryClass/InnerClass.java

@@ -0,0 +1,6 @@
+package test;
+
+class Outer {
+    class Inner {
+    }
+}

compiler/testData/readJavaBinaryClass/InnerClass.kt

@@ -0,0 +1,5 @@
+package test
+
+open class Outer() {
+    open class Inner()
+}

compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.java

@@ -0,0 +1,6 @@
+package test;
+
+class Outer<P> {
+    class Inner<Q extends P> {
+    }
+}

compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.kt

@@ -0,0 +1,5 @@
+package test
+
+open class Outer<erased P>() {
+    open class Inner<erased Q : P>()
+}

compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.java

@@ -0,0 +1,7 @@
+package test;
+
+final class Outer<P> {
+    final class Inner {
+        final <Q extends P> void f() {}
+    }
+}

compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.kt

@@ -0,0 +1,7 @@
+package test
+
+class Outer<erased P>() {
+    class Inner() {
+        fun f<erased Q : P>() {}
+    }
+}

compiler/testData/readKotlinBinaryClass/class/InnerClass.kt

@@ -0,0 +1,5 @@
+package test
+
+class Outer() {
+    class Inner()
+}