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

Refactor JavaSignatureResolver

Browse Source 
Now it has the only method returning Initializer, an object which can be told
to initialize resolved descriptors later, or to obtain these descriptors.
Delete useless methods, combine the remaining ones
This commit is contained in:
Alexander Udalov
2013-08-01 21:02:17 +04:00
parent a1f3a56c25
commit 944d1fc59e
3 changed files with 59 additions and 111 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
+3 -15
View File
@@ -300,10 +300,9 @@ public final class JavaClassResolver {
classDescriptor.setName(javaClass.getName());
List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
= JavaSignatureResolver.makeUninitializedTypeParameters(classDescriptor, javaClass.getTypeParameters());
JavaSignatureResolver.Initializer typeParameterInitializer = signatureResolver.resolveTypeParameters(classDescriptor, javaClass);
classDescriptor.setTypeParameterDescriptors(typeParameterInitializer.getDescriptors());
classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations));
List<JetType> supertypes = Lists.newArrayList();
classDescriptor.setSupertypes(supertypes);
classDescriptor.setVisibility(javaClass.getVisibility());
@@ -314,7 +313,7 @@ public final class JavaClassResolver {
classDescriptor.setScopeForMemberLookup(scope);
classDescriptor.setScopeForConstructorResolve(scope);
signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor);
typeParameterInitializer.initialize();
// TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
List<TypeParameterDescriptor> classTypeParameters = classDescriptor.getTypeConstructor().getParameters();
@@ -400,17 +399,6 @@ public final class JavaClassResolver {
}
}
@NotNull
private static List<TypeParameterDescriptor> getTypeParametersDescriptors(
@NotNull List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
) {
List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
for (JavaSignatureResolver.TypeParameterDescriptorInitialization typeParameter : typeParameterDescriptorInitializations) {
typeParameters.add(typeParameter.getDescriptor());
}
return typeParameters;
}
private void checkFqNamesAreConsistent(@NotNull JavaClass javaClass, @NotNull FqName desiredFqName) {
FqName fqName = javaClass.getFqName();
assert desiredFqName.equals(fqName) : "Inconsistent FQ names: " + fqName + ", " + desiredFqName;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java
+3 -2
View File
@@ -126,8 +126,9 @@ public final class JavaFunctionResolver {
CallableMemberDescriptor.Kind.DECLARATION
);
List<TypeParameterDescriptor> methodTypeParameters =
signatureResolver.resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters());
JavaSignatureResolver.Initializer typeParameterInitializer = signatureResolver.resolveTypeParameters(functionDescriptorImpl, method);
typeParameterInitializer.initialize();
List<TypeParameterDescriptor> methodTypeParameters = typeParameterInitializer.getDescriptors();
TypeVariableResolver typeVariableResolver = new TypeVariableResolver(methodTypeParameters, functionDescriptorImpl);
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java
+53 -94
View File
@@ -16,7 +16,6 @@
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.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
@@ -25,14 +24,12 @@ import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
import org.jetbrains.jet.lang.resolve.java.TypeUsage;
import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameterListOwner;
import org.jetbrains.jet.lang.types.Variance;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import javax.inject.Inject;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.*;
public final class JavaSignatureResolver {
@NotNull
@@ -43,104 +40,66 @@ public final class JavaSignatureResolver {
this.typeTransformer = javaTypeTransformer;
}
public static class TypeParameterDescriptorInitialization {
@NotNull
private final TypeParameterDescriptorImpl descriptor;
private final JavaTypeParameter javaTypeParameter;
private TypeParameterDescriptorInitialization(
@NotNull TypeParameterDescriptorImpl descriptor,
@NotNull JavaTypeParameter javaTypeParameter
) {
this.descriptor = descriptor;
this.javaTypeParameter = javaTypeParameter;
}
@NotNull
public TypeParameterDescriptorImpl getDescriptor() {
return descriptor;
}
}
@NotNull
public static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
@NotNull DeclarationDescriptor container,
@NotNull Collection<JavaTypeParameter> typeParameters
public Initializer resolveTypeParameters(
@NotNull DeclarationDescriptor ownerDescriptor,
@NotNull JavaTypeParameterListOwner typeParameterListOwner
) {
List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
for (JavaTypeParameter typeParameter : typeParameters) {
result.add(makeUninitializedTypeParameter(container, typeParameter));
Initializer result = new Initializer(ownerDescriptor);
for (JavaTypeParameter typeParameter : typeParameterListOwner.getTypeParameters()) {
result.addTypeParameter(typeParameter);
}
return result;
}
@NotNull
private static TypeParameterDescriptorInitialization makeUninitializedTypeParameter(
@NotNull DeclarationDescriptor containingDeclaration,
@NotNull JavaTypeParameter typeParameter
) {
TypeParameterDescriptorImpl typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
containingDeclaration,
Collections.<AnnotationDescriptor>emptyList(), // TODO
false,
Variance.INVARIANT,
typeParameter.getName(),
typeParameter.getIndex()
);
return new TypeParameterDescriptorInitialization(typeParameterDescriptor, typeParameter);
}
public class Initializer {
private final DeclarationDescriptor owner;
private final List<TypeParameterDescriptor> descriptors = new ArrayList<TypeParameterDescriptor>();
private final List<JavaTypeParameter> javaTypeParameters = new ArrayList<JavaTypeParameter>();
private void initializeTypeParameter(
@NotNull TypeParameterDescriptorInitialization initialization,
@NotNull TypeVariableResolver typeVariableResolver
) {
TypeParameterDescriptorImpl typeParameterDescriptor = initialization.descriptor;
Collection<JavaClassifierType> upperBounds = initialization.javaTypeParameter.getUpperBounds();
if (upperBounds.isEmpty()) {
typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
private Initializer(@NotNull DeclarationDescriptor owner) {
this.owner = owner;
}
else {
for (JavaClassifierType upperBound : upperBounds) {
JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver);
typeParameterDescriptor.addUpperBound(transformedType);
private void addTypeParameter(@NotNull JavaTypeParameter typeParameter) {
TypeParameterDescriptorImpl descriptor = TypeParameterDescriptorImpl.createForFurtherModification(
owner,
Collections.<AnnotationDescriptor>emptyList(), // TODO
false,
Variance.INVARIANT,
typeParameter.getName(),
typeParameter.getIndex()
);
descriptors.add(descriptor);
javaTypeParameters.add(typeParameter);
}
@NotNull
public List<TypeParameterDescriptor> getDescriptors() {
return descriptors;
}
public void initialize() {
TypeVariableResolver typeVariableResolver = new TypeVariableResolver(getDescriptors(), owner);
Iterator<TypeParameterDescriptor> descriptorIterator = descriptors.iterator();
Iterator<JavaTypeParameter> typeParameterIterator = javaTypeParameters.iterator();
while (descriptorIterator.hasNext()) {
TypeParameterDescriptorImpl descriptor = (TypeParameterDescriptorImpl) descriptorIterator.next();
Collection<JavaClassifierType> upperBounds = typeParameterIterator.next().getUpperBounds();
if (upperBounds.isEmpty()) {
descriptor.addUpperBound(KotlinBuiltIns.getInstance().getDefaultBound());
}
else {
for (JavaClassifierType upperBound : upperBounds) {
descriptor.addUpperBound(typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver));
}
}
descriptor.setInitialized();
}
}
typeParameterDescriptor.setInitialized();
}
public void initializeTypeParameters(
@NotNull List<TypeParameterDescriptorInitialization> typeParametersInitialization,
@NotNull DeclarationDescriptor typeParametersOwner
) {
List<TypeParameterDescriptor> prevTypeParameters = Lists.newArrayList();
List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
for (TypeParameterDescriptorInitialization typeParameterDescriptor : typeParametersInitialization) {
typeParameters.add(typeParameterDescriptor.descriptor);
}
for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
prevTypeParameters.add(psiTypeParameter.descriptor);
initializeTypeParameter(psiTypeParameter, new TypeVariableResolver(typeParameters, typeParametersOwner));
}
}
@NotNull
public List<TypeParameterDescriptor> resolveTypeParameters(
@NotNull DeclarationDescriptor owner,
@NotNull Collection<JavaTypeParameter> typeParameters
) {
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;
}
}