azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move methods from JavaDescriptorResolver to ClassResolver

Browse Source
This commit is contained in:
Pavel V. Talanov
2012-10-06 19:47:49 +04:00
parent a0bcc27ffa
commit 913659a58a
2 changed files with 112 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+1 -105
View File
@@ -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<JetType> getSupertypes(
PsiClassWrapper psiClass,
ResolverClassData classData,
List<TypeParameterDescriptor> typeParameters
) {
ClassDescriptor classDescriptor = classData.getClassDescriptor();
final List<JetType> result = new ArrayList<JetType>();
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<JetType> 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);
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ClassResolver.java
+111 -3
View File
@@ -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<TypeParameterDescriptor> 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<TypeParameterDescriptor>(0)));
getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData, new ArrayList<TypeParameterDescriptor>(0)));
setUpClassObjectDescriptor(containing, fqName, classData, getClassObjectName(containing.getName()));
return classObjectDescriptor;
}
@@ -291,6 +301,104 @@ public class ClassResolver {
return classObjectDescriptor;
}
public Collection<JetType> getSupertypes(
PsiClassWrapper psiClass,
JavaDescriptorResolveData.ResolverClassData classData,
List<TypeParameterDescriptor> typeParameters
) {
ClassDescriptor classDescriptor = classData.getClassDescriptor();
final List<JetType> result = new ArrayList<JetType>();
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<JetType> 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);