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

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/TypeVariableByPsiResolverImpl.java

-/*
- * 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/TypeVariableByNameResolver.java → compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java

 /*
- * 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.
@@ -17,14 +17,40 @@
 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
- *
- * @see TypeVariableByPsiResolver
  */
-public interface TypeVariableByNameResolver {
+public class TypeVariableResolverFromOuters implements TypeVariableResolver {
+
+    @NotNull
+    private final DeclarationDescriptor outer;
+
+    public TypeVariableResolverFromOuters(@NotNull DeclarationDescriptor outer) {
+        this.outer = outer;
+    }
+
     @NotNull
-    TypeParameterDescriptor getTypeVariable(@NotNull String name);
+    @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/TypeVariableResoverFromTypeDescriptorsInitialization.java → compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java

 /*
- * 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) {
-        super(typeParameters, parent);
+    public TypeVariableResolverFromTypeDescriptors(@NotNull List<TypeParameterDescriptor> typeParameters, @Nullable TypeVariableResolver 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) {
-            if (typeParameter.descriptor.getName().equals(name)) {
-                return typeParameter.descriptor;
+        for (TypeParameterDescriptor typeParameter : typeParameters) {
+            if (typeParameter.getName().equals(name)) {
+                return typeParameter;
             }
         }
         if (parent != null) {

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

 /*
- * 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.
@@ -16,20 +16,23 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import com.intellij.psi.PsiTypeParameter;
-import org.jetbrains.annotations.NotNull;
+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
- *
- * @see TypeVariableByNameResolver
  */
-public interface TypeVariableByPsiResolver {
-    @NotNull
-    TypeParameterDescriptor getTypeVariable(@NotNull PsiTypeParameter psiTypeParameter);
+public class TypeVariableResolvers {
 
-    /** @deprecated */
-    @NotNull
-    TypeParameterDescriptor getTypeVariableByPsiByName(@NotNull String name);
+    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

@@ -68,6 +68,12 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
             throw new IllegalStateException("cannot write with lock level " + lockLevel + " at " + debugName);
         }
     }
+    
+    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

+package test;
+
+abstract class ClassDoesNotOverrideMethod extends java.util.Date {
+}

compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.kt

+package test
+
+abstract class ClassDoesNotOverrideMethod() : java.util.Date() {
+}

compiler/testData/readJavaBinaryClass/InnerClass.java

+package test;
+
+class Outer {
+    class Inner {
+    }
+}

compiler/testData/readJavaBinaryClass/InnerClass.kt

+package test
+
+open class Outer() {
+    open class Inner()
+}

compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.java

+package test;
+
+class Outer<P> {
+    class Inner<Q extends P> {
+    }
+}

compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.kt

+package test
+
+open class Outer<erased P>() {
+    open class Inner<erased Q : P>()
+}

compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.java

+package test;
+
+final class Outer<P> {
+    final class Inner {
+        final <Q extends P> void f() {}
+    }
+}

compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.kt

+package test
+
+class Outer<erased P>() {
+    class Inner() {
+        fun f<erased Q : P>() {}
+    }
+}

compiler/testData/readKotlinBinaryClass/class/InnerClass.kt

+package test
+
+class Outer() {
+    class Inner()
+}