From b67bb356bd8836a2df61a7fd368ca1b348412835 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Wed, 15 Feb 2012 00:02:06 +0400 Subject: [PATCH] fix inner classes in JavaDescriptorResolver, kill type variable by psi resolver --- .../resolve/java/JavaDescriptorResolver.java | 208 +++++++----------- .../resolve/java/JavaTypeTransformer.java | 37 +--- .../java/JetTypeJetSignatureReader.java | 12 +- .../java/TypeVariableByNameResolver.java | 30 --- .../java/TypeVariableByPsiResolver.java | 35 --- .../java/TypeVariableByPsiResolverImpl.java | 68 ------ .../resolve/java/TypeVariableResolver.java | 7 +- .../java/TypeVariableResolverFromOuters.java | 56 +++++ ...eVariableResolverFromTypeDescriptors.java} | 15 +- .../resolve/java/TypeVariableResolvers.java | 38 ++++ .../descriptors/ConstructorDescriptor.java | 1 + .../ConstructorDescriptorImpl.java | 1 + .../LazySubstitutingClassDescriptor.java | 8 +- .../scopes/WritableScopeWithImports.java | 6 + .../ClassDoesNotOverrideMethod.java | 4 + .../ClassDoesNotOverrideMethod.kt | 4 + .../readJavaBinaryClass/InnerClass.java | 6 + .../readJavaBinaryClass/InnerClass.kt | 5 + .../InnerClassReferencesOuterTP.java | 6 + .../InnerClassReferencesOuterTP.kt | 5 + .../MethodReferencesOuterClassTP.java | 7 + .../MethodReferencesOuterClassTP.kt | 7 + .../readKotlinBinaryClass/class/InnerClass.kt | 5 + 23 files changed, 265 insertions(+), 306 deletions(-) delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByNameResolver.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolver.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolverImpl.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java rename compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/{TypeVariableResoverFromTypeDescriptorsInitialization.java => TypeVariableResolverFromTypeDescriptors.java} (63%) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java create mode 100644 compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.java create mode 100644 compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.kt create mode 100644 compiler/testData/readJavaBinaryClass/InnerClass.java create mode 100644 compiler/testData/readJavaBinaryClass/InnerClass.kt create mode 100644 compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.java create mode 100644 compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.kt create mode 100644 compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.java create mode 100644 compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.kt create mode 100644 compiler/testData/readKotlinBinaryClass/class/InnerClass.kt 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 8e4b4de7fe6..d72d17a9580 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 @@ -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 namedMembersMap; + + @NotNull + public abstract List getTypeParameters(); } static abstract class ResolverClassData extends ResolverScopeData { @NotNull public abstract ClassDescriptor getClassDescriptor(); + + @NotNull + @Override + public List 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 getTypeParameters() { + return new ArrayList(0); + } } protected final Map 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( - resolveParentDescriptor(psiClass), kind - ); + DeclarationDescriptor containingDeclaration = resolveParentDescriptor(psiClass); + 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 supertypes = new ArrayList(); - classData.typeParameters = createUninitializedClassTypeParameters(psiClass, classData, new OuterClassTypeVariableByNameResolver()); + TypeVariableResolverFromOuters outerTypeVariableByNameResolver = new TypeVariableResolverFromOuters(containingDeclaration); + + classData.typeParameters = createUninitializedClassTypeParameters(psiClass, classData, outerTypeVariableByNameResolver); List typeParameters = new ArrayList(); 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(), null)); + initializeTypeParameters(classData.typeParameters, new TypeVariableResolverFromTypeDescriptors(new ArrayList(), 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 createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData, TypeVariableByNameResolver typeVariableByNameResolver) { + private List 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 upperBounds = new ArrayList(); @@ -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 resolveClassTypeParametersFromJetSignature(String jetSignature, final PsiClass clazz, - final ClassDescriptor classDescriptor, final TypeVariableByNameResolver outerClassTypeVariableByNameResolver) { + final ClassDescriptor classDescriptor, final TypeVariableResolver outerClassTypeVariableResolver) { final List r = new ArrayList(); - 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 typeParametersInitialization, TypeVariableResolver typeVariableByPsiResolver) { - List prevTypeParameters = new ArrayList(); + List prevTypeParameters = new ArrayList(); for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) { - prevTypeParameters.add(psiTypeParameter); - initializeTypeParameter(psiTypeParameter, new TypeVariableResoverFromTypeDescriptorsInitialization(prevTypeParameters, typeVariableByPsiResolver)); + prevTypeParameters.add(psiTypeParameter.descriptor); + initializeTypeParameter(psiTypeParameter, new TypeVariableResolverFromTypeDescriptors(prevTypeParameters, typeVariableByPsiResolver)); } } - private Collection getSupertypes(PsiClassWrapper psiClass, List typeParameters) { + private Collection getSupertypes(PsiClassWrapper psiClass, List typeParameters) { final List result = new ArrayList(); 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().getImplementsListTypes(), new TypeVariableResoverFromTypeDescriptorsInitialization(typeParameters, null)); + transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), new TypeVariableResolverFromTypeDescriptors(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 classTypeParameterDescriptorInitialization; - if (scopeData instanceof ResolverBinaryClassData) { - classTypeParameterDescriptorInitialization = ((ResolverBinaryClassData) scopeData).typeParameters; - } else { - classTypeParameterDescriptorInitialization = new ArrayList(0); - } + final List classTypeParameterDescriptorInitialization = scopeData.getTypeParameters(); - 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 typeParametersInitialization = new ArrayList(0); + List typeParametersInitialization = new ArrayList(0); if (members.setter != null) { PsiMethodWrapper method = (PsiMethodWrapper) members.setter.getMember(); @@ -1111,14 +1112,14 @@ public class JavaDescriptorResolver { } List typeParameters = new ArrayList(); - for (TypeParameterDescriptorInitialization typeParameter : typeParametersInitialization) { - typeParameters.add(typeParameter.descriptor); + for (TypeParameterDescriptor typeParameter : typeParametersInitialization) { + typeParameters.add(typeParameter); } - List typeParametersForReceiver = new ArrayList(); + List typeParametersForReceiver = new ArrayList(); 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) { @@ -1255,28 +1256,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 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; - final List classTypeParameters; - final List classTypeParameterDescriptorsInitialization; + ClassOrNamespaceDescriptor classDescriptor; + final List classTypeParameters = scopeData.getTypeParameters(); if (scopeData instanceof ResolverBinaryClassData) { ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass()); classDescriptor = classClassDescriptor; - classTypeParameters = classClassDescriptor.getTypeConstructor().getParameters(); - classTypeParameterDescriptorsInitialization = new ArrayList(); - getAllTypeParameterDescriptorInitialization(psiClass, classTypeParameterDescriptorsInitialization); - //classTypeParameterDescriptorsInitialization = ((ResolverClassData) scopeData).typeParameters; } else { classDescriptor = resolveNamespace(method.getPsiMethod().getContainingClass()); - classTypeParameters = new ArrayList(0); - classTypeParameterDescriptorsInitialization = new ArrayList(0); } if (classDescriptor == null) { return null; @@ -1424,54 +1396,21 @@ public class JavaDescriptorResolver { ); methodDescriptorCache.put(method.getPsiMethod(), functionDescriptorImpl); - // TODO: add outer classes - TypeVariableResolver typeVariableResolverForParameters = new TypeVariableResoverFromTypeDescriptorsInitialization(classTypeParameterDescriptorsInitialization, null); + TypeVariableResolver typeVariableResolverForParameters = TypeVariableResolvers.classTypeVariableResolver(classDescriptor); - final List methodTypeParametersInitialization = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters); + final List methodTypeParametersInitialization = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters); List methodTypeParameters = new ArrayList(); - for (TypeParameterDescriptorInitialization typeParameterDescriptorInitialization : methodTypeParametersInitialization) { - methodTypeParameters.add(typeParameterDescriptorInitialization.descriptor); + for (TypeParameterDescriptor typeParameterDescriptorInitialization : methodTypeParametersInitialization) { + 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) { - if (typeParameter.descriptor.getName().equals(name)) { - return typeParameter.descriptor; + for (TypeParameterDescriptor typeParameter : methodTypeParametersInitialization) { + if (typeParameter.getName().equals(name)) { + return typeParameter; } } for (TypeParameterDescriptor typeParameter : classTypeParameters) { @@ -1539,20 +1478,27 @@ public class JavaDescriptorResolver { } } - private List resolveMethodTypeParameters( + private List resolveMethodTypeParameters( @NotNull PsiMethodWrapper method, @NotNull DeclarationDescriptor functionDescriptor, @NotNull TypeVariableResolver classTypeVariableResolver) { - List typeParameters; + List 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(typeParameters, classTypeVariableResolver); + initializeTypeParameters(typeParametersIntialization, classTypeVariableResolver); + + List typeParameters = Lists.newArrayListWithCapacity(typeParametersIntialization.size()); + + for (TypeParameterDescriptorInitialization tpdi : typeParametersIntialization) { + typeParameters.add(tpdi.descriptor); + } + 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 resolveMethodTypeParametersFromJetSignature(String jetSignature, final PsiMethod method, - final DeclarationDescriptor functionDescriptor, final TypeVariableByNameResolver classTypeVariableByNameResolver) + final DeclarationDescriptor functionDescriptor, final TypeVariableResolver classTypeVariableResolver) { final List r = new ArrayList(); - 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 resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) { + if (staticMembers) { + return new ArrayList(0); + } + PsiClass[] innerPsiClasses = psiClass.getInnerClasses(); List r = new ArrayList(innerPsiClasses.length); for (PsiClass innerPsiClass : innerPsiClasses) { 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 0f1ac47a803..cc466287615 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 @@ -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() { @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() { @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)); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index 3db2a3ee8b3..08623eb8827 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/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); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByNameResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByNameResolver.java deleted file mode 100644 index 55d2ccf71df..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByNameResolver.java +++ /dev/null @@ -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); -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolver.java deleted file mode 100644 index f59035d4ac2..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolver.java +++ /dev/null @@ -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); -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolverImpl.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolverImpl.java deleted file mode 100644 index 645c6f29ad4..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableByPsiResolverImpl.java +++ /dev/null @@ -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 typeParameters; - @Nullable - private final TypeVariableByPsiResolver parent; - - public TypeVariableByPsiResolverImpl(@NotNull List 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 - } -} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java index efea3521b7a..16eb18a400c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolver.java +++ b/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); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromOuters.java new file mode 100644 index 00000000000..c3d8a87a4a6 --- /dev/null +++ b/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()); + } + } + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResoverFromTypeDescriptorsInitialization.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java similarity index 63% rename from compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResoverFromTypeDescriptorsInitialization.java rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java index b7cf13231ef..8c2713267d1 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResoverFromTypeDescriptorsInitialization.java +++ b/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 typeParameters; + private final List typeParameters; @Nullable private final TypeVariableResolver parent; - public TypeVariableResoverFromTypeDescriptorsInitialization(@NotNull List typeParameters, @Nullable TypeVariableResolver parent) { - super(typeParameters, parent); + public TypeVariableResolverFromTypeDescriptors(@NotNull List 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) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolvers.java new file mode 100644 index 00000000000..9c4c1232120 --- /dev/null +++ b/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(0), null); + } + } + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java index 8c7936d52bc..17d1edf81fe 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java +++ b/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; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java index 83f9af0d4b2..0417994ceb1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java +++ b/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; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java index 01966ff4b2c..12024efc629 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java +++ b/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 getConstructors() { - throw new UnsupportedOperationException(); // TODO + Set r = Sets.newHashSet(); + for (ConstructorDescriptor constructor : original.getConstructors()) { + r.add((ConstructorDescriptor) constructor.substitute(getSubstitutor())); + } + return r; } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java index a5e1e6722b8..8db7872b9fe 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java +++ b/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); + } + } diff --git a/compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.java b/compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.java new file mode 100644 index 00000000000..d25d62fd274 --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.java @@ -0,0 +1,4 @@ +package test; + +abstract class ClassDoesNotOverrideMethod extends java.util.Date { +} diff --git a/compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.kt b/compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.kt new file mode 100644 index 00000000000..6d972517626 --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/ClassDoesNotOverrideMethod.kt @@ -0,0 +1,4 @@ +package test + +abstract class ClassDoesNotOverrideMethod() : java.util.Date() { +} diff --git a/compiler/testData/readJavaBinaryClass/InnerClass.java b/compiler/testData/readJavaBinaryClass/InnerClass.java new file mode 100644 index 00000000000..bc4683aef06 --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/InnerClass.java @@ -0,0 +1,6 @@ +package test; + +class Outer { + class Inner { + } +} diff --git a/compiler/testData/readJavaBinaryClass/InnerClass.kt b/compiler/testData/readJavaBinaryClass/InnerClass.kt new file mode 100644 index 00000000000..494763e3159 --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/InnerClass.kt @@ -0,0 +1,5 @@ +package test + +open class Outer() { + open class Inner() +} diff --git a/compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.java b/compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.java new file mode 100644 index 00000000000..1c48f81e45b --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.java @@ -0,0 +1,6 @@ +package test; + +class Outer

{ + class Inner { + } +} diff --git a/compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.kt b/compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.kt new file mode 100644 index 00000000000..1cbfe66f598 --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/InnerClassReferencesOuterTP.kt @@ -0,0 +1,5 @@ +package test + +open class Outer() { + open class Inner() +} diff --git a/compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.java b/compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.java new file mode 100644 index 00000000000..aa9a92f89ff --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.java @@ -0,0 +1,7 @@ +package test; + +final class Outer

{ + final class Inner { + final void f() {} + } +} diff --git a/compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.kt b/compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.kt new file mode 100644 index 00000000000..4f5fe948210 --- /dev/null +++ b/compiler/testData/readJavaBinaryClass/MethodReferencesOuterClassTP.kt @@ -0,0 +1,7 @@ +package test + +class Outer() { + class Inner() { + fun f() {} + } +} diff --git a/compiler/testData/readKotlinBinaryClass/class/InnerClass.kt b/compiler/testData/readKotlinBinaryClass/class/InnerClass.kt new file mode 100644 index 00000000000..7f039188a28 --- /dev/null +++ b/compiler/testData/readKotlinBinaryClass/class/InnerClass.kt @@ -0,0 +1,5 @@ +package test + +class Outer() { + class Inner() +}