From 913659a58adddc85f3c3bdfa4df9cba4748156ec Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Sat, 6 Oct 2012 19:47:49 +0400 Subject: [PATCH] Move methods from JavaDescriptorResolver to ClassResolver --- .../resolve/java/JavaDescriptorResolver.java | 106 +--------------- .../resolve/java/resolver/ClassResolver.java | 114 +++++++++++++++++- 2 files changed, 112 insertions(+), 108 deletions(-) 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 fba1b07381a..8c8e35393e8 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 @@ -22,12 +22,10 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.*; import gnu.trove.THashMap; import gnu.trove.TObjectHashingStrategy; -import jet.typeinfo.TypeInfoVariance; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolveData.ResolverClassData; @@ -45,15 +43,9 @@ import org.jetbrains.jet.lang.resolve.name.FqNameBase; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; -import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; -import org.jetbrains.jet.rt.signature.JetSignatureAdapter; -import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; -import org.jetbrains.jet.rt.signature.JetSignatureReader; -import org.jetbrains.jet.rt.signature.JetSignatureVisitor; import javax.inject.Inject; import java.util.*; @@ -148,7 +140,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes @Nullable - private ClassDescriptor resolveJavaLangObject() { + public ClassDescriptor resolveJavaLangObject() { ClassDescriptor clazz = classResolver.resolveClass(OBJECT_FQ_NAME, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); if (clazz == null) { // TODO: warning @@ -276,104 +268,8 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return ns; } - public Collection getSupertypes( - PsiClassWrapper psiClass, - ResolverClassData classData, - List typeParameters - ) { - ClassDescriptor classDescriptor = classData.getClassDescriptor(); - - final List result = new ArrayList(); - - String context = "class " + psiClass.getQualifiedName(); - - if (psiClass.getJetClass().signature().length() > 0) { - final TypeVariableResolver typeVariableResolver = - TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); - - new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() { - @Override - public JetSignatureVisitor visitFormalTypeParameter(String name, TypeInfoVariance variance, boolean reified) { - // TODO: collect - return new JetSignatureAdapter(); - } - - @Override - public JetSignatureVisitor visitSuperclass() { - return new JetTypeJetSignatureReader(semanticServices, JetStandardLibrary.getInstance(), typeVariableResolver) { - @Override - protected void done(@NotNull JetType jetType) { - if (!jetType.equals(JetStandardClasses.getAnyType())) { - result.add(jetType); - } - } - }; - } - - @Override - public JetSignatureVisitor visitInterface() { - return visitSuperclass(); - } - }); - } - else { - TypeVariableResolver typeVariableResolverForSupertypes = - TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); - transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes); - transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes); - } - - for (JetType supertype : result) { - if (ErrorUtils.isErrorType(supertype)) { - trace.record(BindingContext.INCOMPLETE_HIERARCHY, classDescriptor); - } - } - - if (result.isEmpty()) { - if (classData.isKotlin() - || OBJECT_FQ_NAME.equalsTo(psiClass.getQualifiedName()) - // TODO: annotations - || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) { - result.add(JetStandardClasses.getAnyType()); - } - else { - ClassDescriptor object = resolveJavaLangObject(); - if (object != null) { - result.add(object.getDefaultType()); - } - else { - result.add(JetStandardClasses.getAnyType()); - } - } - } - return result; - } - - private void transformSupertypeList(List result, PsiClassType[] extendsListTypes, TypeVariableResolver typeVariableResolver) { - for (PsiClassType type : extendsListTypes) { - PsiClass resolved = type.resolve(); - if (resolved != null) { - final String qualifiedName = resolved.getQualifiedName(); - assert qualifiedName != null; - if (JvmStdlibNames.JET_OBJECT.getFqName().equalsTo(qualifiedName)) { - continue; - } - } - - JetType transform = semanticServices.getTypeTransformer() - .transformToType(type, JavaTypeTransformer.TypeUsage.SUPERTYPE, typeVariableResolver); - if (ErrorUtils.isErrorType(transform)) { - continue; - } - - result.add(TypeUtils.makeNotNullable(transform)); - } - } - @Nullable public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { - // First, let's check that there is no Kotlin package: - return namespaceResolver.resolveNamespace(qualifiedName, searchRule); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java index 8dd305e913e..aaa805a6cae 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java @@ -18,7 +18,9 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.google.common.collect.Lists; import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiClassType; import com.intellij.psi.PsiModifier; +import jet.typeinfo.TypeInfoVariance; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -35,9 +37,18 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; +import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; +import org.jetbrains.jet.rt.signature.JetSignatureAdapter; +import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; +import org.jetbrains.jet.rt.signature.JetSignatureReader; +import org.jetbrains.jet.rt.signature.JetSignatureVisitor; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.List; @@ -182,7 +193,7 @@ public class ClassResolver { // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes List classTypeParameters = classData.getClassDescriptor().getTypeConstructor().getParameters(); - supertypes.addAll(javaDescriptorResolver.getSupertypes(new PsiClassWrapper(psiClass), classData, classTypeParameters)); + supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData, classTypeParameters)); MutableClassDescriptorLite classObject = createClassObjectDescriptor(classData.getClassDescriptor(), psiClass); if (classObject != null) { @@ -232,8 +243,7 @@ public class ClassResolver { ClassDescriptorFromJvmBytecode classObjectDescriptor = classData.getClassDescriptor(); classObjectDescriptor.setSupertypes( - javaDescriptorResolver - .getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData, new ArrayList(0))); + getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData, new ArrayList(0))); setUpClassObjectDescriptor(containing, fqName, classData, getClassObjectName(containing.getName())); return classObjectDescriptor; } @@ -291,6 +301,104 @@ public class ClassResolver { return classObjectDescriptor; } + public Collection getSupertypes( + PsiClassWrapper psiClass, + JavaDescriptorResolveData.ResolverClassData classData, + List typeParameters + ) { + ClassDescriptor classDescriptor = classData.getClassDescriptor(); + + final List result = new ArrayList(); + + String context = "class " + psiClass.getQualifiedName(); + + if (psiClass.getJetClass().signature().length() > 0) { + final TypeVariableResolver typeVariableResolver = + TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); + + new JetSignatureReader(psiClass.getJetClass().signature()).accept(new JetSignatureExceptionsAdapter() { + @Override + public JetSignatureVisitor visitFormalTypeParameter(String name, TypeInfoVariance variance, boolean reified) { + // TODO: collect + return new JetSignatureAdapter(); + } + + @Override + public JetSignatureVisitor visitSuperclass() { + return new JetTypeJetSignatureReader(javaDescriptorResolver.getSemanticServices(), JetStandardLibrary.getInstance(), typeVariableResolver) { + @Override + protected void done(@NotNull JetType jetType) { + if (!jetType.equals(JetStandardClasses.getAnyType())) { + result.add(jetType); + } + } + }; + } + + @Override + public JetSignatureVisitor visitInterface() { + return visitSuperclass(); + } + }); + } + else { + TypeVariableResolver typeVariableResolverForSupertypes = + TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, classDescriptor, context); + transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), typeVariableResolverForSupertypes); + transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), typeVariableResolverForSupertypes); + } + + for (JetType supertype : result) { + if (ErrorUtils.isErrorType(supertype)) { + javaDescriptorResolver.getTrace().record(BindingContext.INCOMPLETE_HIERARCHY, classDescriptor); + } + } + + if (result.isEmpty()) { + if (classData.isKotlin() + || JavaDescriptorResolver.OBJECT_FQ_NAME.equalsTo(psiClass.getQualifiedName()) + // TODO: annotations + || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) { + result.add(JetStandardClasses.getAnyType()); + } + else { + ClassDescriptor object = javaDescriptorResolver.resolveJavaLangObject(); + if (object != null) { + result.add(object.getDefaultType()); + } + else { + result.add(JetStandardClasses.getAnyType()); + } + } + } + return result; + } + + private void transformSupertypeList( + List result, + PsiClassType[] extendsListTypes, + TypeVariableResolver typeVariableResolver + ) { + for (PsiClassType type : extendsListTypes) { + PsiClass resolved = type.resolve(); + if (resolved != null) { + final String qualifiedName = resolved.getQualifiedName(); + assert qualifiedName != null; + if (JvmStdlibNames.JET_OBJECT.getFqName().equalsTo(qualifiedName)) { + continue; + } + } + + JetType transform = javaDescriptorResolver.getSemanticServices().getTypeTransformer() + .transformToType(type, JavaTypeTransformer.TypeUsage.SUPERTYPE, typeVariableResolver); + if (ErrorUtils.isErrorType(transform)) { + continue; + } + + result.add(TypeUtils.makeNotNullable(transform)); + } + } + public static ClassKind getClassKind(@NotNull PsiClass psiClass, @NotNull JetClassAnnotation jetClassAnnotation) { if (psiClass.isInterface()) { return (psiClass.isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT);