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

Refactor TypeVariableResolver

Browse Source 
Delete 'context' field which was used only for debugging
This commit is contained in:
Alexander Udalov
2013-08-01 20:16:06 +04:00
parent 04516376c0
commit a1f3a56c25
8 changed files with 56 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java
+2 -3
View File
@@ -301,7 +301,7 @@ public final class JavaClassResolver {
classDescriptor.setName(javaClass.getName());
List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
= JavaSignatureResolver.createUninitializedClassTypeParameters(javaClass, classDescriptor);
= JavaSignatureResolver.makeUninitializedTypeParameters(classDescriptor, javaClass.getTypeParameters());
classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations));
List<JetType> supertypes = Lists.newArrayList();
@@ -314,8 +314,7 @@ public final class JavaClassResolver {
classDescriptor.setScopeForMemberLookup(scope);
classDescriptor.setScopeForConstructorResolve(scope);
signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor,
"class " + javaClass.getFqName());
signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor);
// TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
List<TypeParameterDescriptor> classTypeParameters = classDescriptor.getTypeConstructor().getParameters();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java
+6 -7
View File
@@ -84,7 +84,7 @@ public final class JavaConstructorResolver {
}
else {
for (JavaMethod constructor : constructors) {
ConstructorDescriptor descriptor = resolveConstructor(javaClass, constructor, containingClass);
ConstructorDescriptor descriptor = resolveConstructor(constructor, containingClass, javaClass.isStatic());
result.add(descriptor);
ContainerUtil.addIfNotNull(result, resolveSamAdapter(descriptor));
}
@@ -117,8 +117,7 @@ public final class JavaConstructorResolver {
List<ValueParameterDescriptor> valueParameters;
if (isAnnotation) {
TypeVariableResolver typeVariableResolver =
new TypeVariableResolver(typeParameters, containingClass, "class " + javaClass.getFqName());
TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, containingClass);
valueParameters = resolveAnnotationParameters(javaClass, constructorDescriptor, typeVariableResolver);
}
else {
@@ -183,9 +182,9 @@ public final class JavaConstructorResolver {
@NotNull
private ConstructorDescriptor resolveConstructor(
@NotNull JavaClass javaClass,
@NotNull JavaMethod constructor,
@NotNull ClassDescriptor classDescriptor
@NotNull ClassDescriptor classDescriptor,
boolean isStaticClass
) {
ConstructorDescriptor alreadyResolved = trace.get(BindingContext.CONSTRUCTOR, constructor.getPsi());
if (alreadyResolved != null) {
@@ -201,7 +200,7 @@ public final class JavaConstructorResolver {
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors(
constructorDescriptor, constructor,
new TypeVariableResolver(typeParameters, classDescriptor, "constructor of class " + javaClass.getFqName())
new TypeVariableResolver(typeParameters, classDescriptor)
);
if (valueParameterDescriptors.getReceiverType() != null) {
@@ -222,7 +221,7 @@ public final class JavaConstructorResolver {
constructorDescriptor.initialize(typeParameters,
valueParameterDescriptors.getDescriptors(),
constructor.getVisibility(),
javaClass.isStatic());
isStaticClass);
trace.record(BindingContext.CONSTRUCTOR, constructor.getPsi(), constructorDescriptor);
return constructorDescriptor;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java
+9 -6
View File
@@ -28,7 +28,10 @@ import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent;
import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.java.*;
import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
import org.jetbrains.jet.lang.resolve.java.JavaBindingContext;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.TypeUsage;
import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData;
@@ -123,14 +126,14 @@ public final class JavaFunctionResolver {
CallableMemberDescriptor.Kind.DECLARATION
);
List<TypeParameterDescriptor> methodTypeParameters = signatureResolver.resolveMethodTypeParameters(method, functionDescriptorImpl);
List<TypeParameterDescriptor> methodTypeParameters =
signatureResolver.resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters());
TypeVariableResolver methodTypeVariableResolver = new TypeVariableResolver(
methodTypeParameters, functionDescriptorImpl, "method " + method.getName() + " in class " + method.getContainingClass());
TypeVariableResolver typeVariableResolver = new TypeVariableResolver(methodTypeParameters, functionDescriptorImpl);
JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = parameterResolver
.resolveParameterDescriptors(functionDescriptorImpl, method, methodTypeVariableResolver);
JetType returnType = makeReturnType(returnJavaType, method, methodTypeVariableResolver);
.resolveParameterDescriptors(functionDescriptorImpl, method, typeVariableResolver);
JetType returnType = makeReturnType(returnJavaType, method, typeVariableResolver);
List<String> signatureErrors = Lists.newArrayList();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java
+7 -14
View File
@@ -77,8 +77,7 @@ public final class JavaPropertyResolver {
if (fields.size() == 1) {
JavaField field = fields.iterator().next();
if (DescriptorResolverUtils.isCorrectOwnerForEnumMember(ownerDescriptor, field)) {
propertiesFromCurrent.add(resolveProperty(ownerDescriptor, propertyName,
"class or namespace " + DescriptorUtils.getFQName(ownerDescriptor), field));
propertiesFromCurrent.add(resolveProperty(ownerDescriptor, propertyName, field));
}
}
@@ -124,23 +123,16 @@ public final class JavaPropertyResolver {
}
@NotNull
private PropertyDescriptor resolveProperty(
@NotNull ClassOrNamespaceDescriptor owner,
@NotNull Name propertyName,
@NotNull String context,
@NotNull JavaField field
) {
private PropertyDescriptor resolveProperty(@NotNull ClassOrNamespaceDescriptor owner, @NotNull Name name, @NotNull JavaField field) {
boolean isVar = !field.isFinal();
PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, propertyName, field, isVar);
PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, name, field, isVar);
propertyDescriptor.initialize(null, null);
TypeVariableResolver typeVariableResolverForPropertyInternals =
new TypeVariableResolver(Collections.<TypeParameterDescriptor>emptyList(), propertyDescriptor,
"property " + propertyName + " in " + context);
TypeVariableResolver typeVariableResolver =
new TypeVariableResolver(Collections.<TypeParameterDescriptor>emptyList(), propertyDescriptor);
JetType propertyType = getPropertyType(field, typeVariableResolverForPropertyInternals);
JetType propertyType = getPropertyType(field, typeVariableResolver);
propertyType = getAlternativeSignatureData(isVar, field, propertyDescriptor, propertyType);
@@ -150,6 +142,7 @@ public final class JavaPropertyResolver {
DescriptorUtils.getExpectedThisObjectIfNeeded(owner),
(JetType) null
);
trace.record(BindingContext.VARIABLE, field.getPsi(), propertyDescriptor);
trace.record(JavaBindingContext.IS_DECLARED_IN_JAVA, propertyDescriptor);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java
+21 -43
View File
@@ -18,15 +18,12 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
import com.google.common.collect.Lists;
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.TypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
import org.jetbrains.jet.lang.resolve.java.TypeUsage;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod;
import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.Variance;
@@ -66,7 +63,7 @@ public final class JavaSignatureResolver {
}
@NotNull
private static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
public static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
@NotNull DeclarationDescriptor container,
@NotNull Collection<JavaTypeParameter> typeParameters
) {
@@ -94,17 +91,17 @@ public final class JavaSignatureResolver {
}
private void initializeTypeParameter(
TypeParameterDescriptorInitialization typeParameter,
TypeVariableResolver typeVariableByPsiResolver
@NotNull TypeParameterDescriptorInitialization initialization,
@NotNull TypeVariableResolver typeVariableResolver
) {
TypeParameterDescriptorImpl typeParameterDescriptor = typeParameter.descriptor;
Collection<JavaClassifierType> upperBounds = typeParameter.javaTypeParameter.getUpperBounds();
TypeParameterDescriptorImpl typeParameterDescriptor = initialization.descriptor;
Collection<JavaClassifierType> upperBounds = initialization.javaTypeParameter.getUpperBounds();
if (upperBounds.isEmpty()) {
typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
}
else {
for (JavaClassifierType upperBound : upperBounds) {
JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver);
JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver);
typeParameterDescriptor.addUpperBound(transformedType);
}
}
@@ -112,9 +109,8 @@ public final class JavaSignatureResolver {
}
public void initializeTypeParameters(
List<TypeParameterDescriptorInitialization> typeParametersInitialization,
@NotNull DeclarationDescriptor typeParametersOwner,
@NotNull String context
@NotNull List<TypeParameterDescriptorInitialization> typeParametersInitialization,
@NotNull DeclarationDescriptor typeParametersOwner
) {
List<TypeParameterDescriptor> prevTypeParameters = Lists.newArrayList();
@@ -126,43 +122,25 @@ public final class JavaSignatureResolver {
for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
prevTypeParameters.add(psiTypeParameter.descriptor);
initializeTypeParameter(psiTypeParameter, new TypeVariableResolver(typeParameters, typeParametersOwner, context));
initializeTypeParameter(psiTypeParameter, new TypeVariableResolver(typeParameters, typeParametersOwner));
}
}
@NotNull
public static List<TypeParameterDescriptorInitialization> createUninitializedClassTypeParameters(
JavaClass javaClass, ClassDescriptor classDescriptor
public List<TypeParameterDescriptor> resolveTypeParameters(
@NotNull DeclarationDescriptor owner,
@NotNull Collection<JavaTypeParameter> typeParameters
) {
List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
for (JavaTypeParameter typeParameter : javaClass.getTypeParameters()) {
TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(classDescriptor, typeParameter);
result.add(typeParameterDescriptor);
List<TypeParameterDescriptorInitialization> initializations = makeUninitializedTypeParameters(owner, typeParameters);
initializeTypeParameters(initializations, owner);
List<TypeParameterDescriptor> result = Lists.newArrayListWithCapacity(initializations.size());
for (TypeParameterDescriptorInitialization initialization : initializations) {
result.add(initialization.descriptor);
}
return result;
}
@NotNull
public List<TypeParameterDescriptor> resolveMethodTypeParameters(
@NotNull JavaMethod method,
@NotNull DeclarationDescriptor functionDescriptor
) {
List<TypeParameterDescriptorInitialization> typeParametersIntialization =
makeUninitializedTypeParameters(functionDescriptor, method.getTypeParameters());
JavaClass containingClass = method.getContainingClass();
assert containingClass != null;
initializeTypeParameters(typeParametersIntialization, functionDescriptor,
"method " + method.getName() + " in class " + containingClass.getFqName());
List<TypeParameterDescriptor> typeParameters = Lists.newArrayListWithCapacity(typeParametersIntialization.size());
for (TypeParameterDescriptorInitialization tpdi : typeParametersIntialization) {
typeParameters.add(tpdi.descriptor);
}
return typeParameters;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java
+1 -2
View File
@@ -69,8 +69,7 @@ public final class JavaSupertypeResolver {
@NotNull JavaClass javaClass,
@NotNull List<TypeParameterDescriptor> typeParameters
) {
TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, classDescriptor,
"class " + javaClass.getFqName());
TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, classDescriptor);
List<JetType> result = transformSupertypeList(javaClass.getSupertypes(), typeVariableResolver);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java
+1 -1
View File
@@ -143,7 +143,7 @@ public class JavaTypeTransformer {
return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet);
}
TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName().asString());
TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName());
// In Java: ArrayList<T>
// In Kotlin: ArrayList<T>, not ArrayList<T?>
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java
+9 -12
View File
@@ -22,25 +22,22 @@ 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.TypeParameterDescriptor;
import org.jetbrains.jet.lang.resolve.name.Name;
import java.util.List;
/* package */ class TypeVariableResolver {
@NotNull
protected final List<TypeParameterDescriptor> typeParameters;
private final List<TypeParameterDescriptor> typeParameters;
@NotNull
protected final DeclarationDescriptor owner;
@NotNull
protected final String context;
private final DeclarationDescriptor owner;
public TypeVariableResolver(
@NotNull List<TypeParameterDescriptor> typeParameters,
@NotNull DeclarationDescriptor owner,
@NotNull String context
@NotNull DeclarationDescriptor owner
) {
this.typeParameters = typeParameters;
this.owner = owner;
this.context = context;
assert ContainerUtil.and(typeParameters, new Condition<TypeParameterDescriptor>() {
@Override
@@ -51,18 +48,18 @@ import java.util.List;
}
@NotNull
public TypeParameterDescriptor getTypeVariable(@NotNull String name) {
public TypeParameterDescriptor getTypeVariable(@NotNull Name name) {
return getTypeVariable(name, typeParameters, owner);
}
@NotNull
private TypeParameterDescriptor getTypeVariable(
@NotNull String name,
private static TypeParameterDescriptor getTypeVariable(
@NotNull Name name,
@NotNull List<TypeParameterDescriptor> typeParameters,
@NotNull DeclarationDescriptor owner
) {
for (TypeParameterDescriptor typeParameter : typeParameters) {
if (typeParameter.getName().asString().equals(name)) {
if (typeParameter.getName().equals(name)) {
return typeParameter;
}
}
@@ -72,6 +69,6 @@ import java.util.List;
return getTypeVariable(name, ((ClassDescriptor) container).getTypeConstructor().getParameters(), container);
}
throw new IllegalStateException("Type parameter not found by name '" + name + "' in " + context);
throw new IllegalStateException("Type parameter not found by name: " + name);
}
}