From b8f9ef9910f1171d61473464bdbb009eb9389acb Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 6 Sep 2013 20:42:13 +0400 Subject: [PATCH] Extract interface out of TypeVariableResolver Also make getTypeVariable() nullable: when a type is not found, it's better to use error type instead of throwing an exception --- .../resolver/JavaConstructorResolver.java | 4 +- .../java/resolver/JavaFunctionResolver.java | 2 +- .../java/resolver/JavaPropertyResolver.java | 2 +- .../java/resolver/JavaSupertypeResolver.java | 2 +- .../resolver/JavaTypeParameterResolver.java | 2 +- .../java/resolver/JavaTypeTransformer.java | 7 +- .../java/resolver/TypeVariableResolver.java | 58 +++----------- .../resolver/TypeVariableResolverImpl.java | 75 +++++++++++++++++++ 8 files changed, 95 insertions(+), 57 deletions(-) create mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java index 8ffb87a1b31..a788c606c96 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java @@ -118,7 +118,7 @@ public final class JavaConstructorResolver { List valueParameters; if (isAnnotation) { - TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, containingClass); + TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(typeParameters, containingClass); valueParameters = resolveAnnotationParameters(javaClass, constructorDescriptor, typeVariableResolver); } else { @@ -202,7 +202,7 @@ public final class JavaConstructorResolver { List valueParameters = valueParameterResolver.resolveValueParameters( constructorDescriptor, constructor, - new TypeVariableResolver(typeParameters, classDescriptor) + new TypeVariableResolverImpl(typeParameters, classDescriptor) ); ExternalSignatureResolver.AlternativeMethodSignature effectiveSignature = externalSignatureResolver diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index ecfbfc14f8f..1f8eb43ead1 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -126,7 +126,7 @@ public final class JavaFunctionResolver { typeParameterInitializer.initialize(); List methodTypeParameters = typeParameterInitializer.getDescriptors(); - TypeVariableResolver typeVariableResolver = new TypeVariableResolver(methodTypeParameters, functionDescriptorImpl); + TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(methodTypeParameters, functionDescriptorImpl); List valueParameters = valueParameterResolver.resolveValueParameters(functionDescriptorImpl, method, typeVariableResolver); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index 17247f928c2..b25f823c6db 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -109,7 +109,7 @@ public final class JavaPropertyResolver { propertyDescriptor.initialize(null, null); TypeVariableResolver typeVariableResolver = - new TypeVariableResolver(Collections.emptyList(), propertyDescriptor); + new TypeVariableResolverImpl(Collections.emptyList(), propertyDescriptor); JetType propertyType = getPropertyType(field, typeVariableResolver); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java index 3db2d43ab03..6345a3c5038 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java @@ -59,7 +59,7 @@ public final class JavaSupertypeResolver { @NotNull JavaClass javaClass, @NotNull List typeParameters ) { - TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, classDescriptor); + TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(typeParameters, classDescriptor); List result = transformSupertypeList(javaClass.getSupertypes(), typeVariableResolver); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java index 10f6f34d706..4994915d3af 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeParameterResolver.java @@ -80,7 +80,7 @@ public final class JavaTypeParameterResolver { } public void initialize() { - TypeVariableResolver typeVariableResolver = new TypeVariableResolver(getDescriptors(), owner); + TypeVariableResolver typeVariableResolver = new TypeVariableResolverImpl(getDescriptors(), owner); Iterator descriptorIterator = descriptors.iterator(); Iterator typeParameterIterator = javaTypeParameters.iterator(); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java index e8211c7a4e3..3ba3e15a5da 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java @@ -84,7 +84,7 @@ public class JavaTypeTransformer { JavaClassifierType classifierType = (JavaClassifierType) type; JetType jetType = transformClassifierType(classifierType, howThisTypeIsUsed, typeVariableResolver); if (jetType == null) { - return ErrorUtils.createErrorType("Unresolved java class: " + classifierType.getPresentableText()); + return ErrorUtils.createErrorType("Unresolved java classifier: " + classifierType.getPresentableText()); } return jetType; } @@ -140,14 +140,15 @@ public class JavaTypeTransformer { return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet); } - TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName()); + TypeParameterDescriptor descriptor = typeVariableResolver.getTypeVariable(typeParameter.getName()); + if (descriptor == null) return null; // In Java: ArrayList // In Kotlin: ArrayList, not ArrayList // nullability will be taken care of in individual member signatures boolean nullable = !EnumSet.of(TYPE_ARGUMENT, UPPER_BOUND, SUPERTYPE_ARGUMENT).contains(howThisTypeIsUsed); - return TypeUtils.makeNullableIfNeeded(typeParameterDescriptor.getDefaultType(), nullable); + return TypeUtils.makeNullableIfNeeded(descriptor.getDefaultType(), nullable); } @Nullable diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java index 2ba08461b44..9ee8600b1a4 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java @@ -17,57 +17,19 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.resolve.name.Name; -import java.util.List; - -/* package */ class TypeVariableResolver { - @NotNull - private final List typeParameters; - @NotNull - private final DeclarationDescriptor owner; - - public TypeVariableResolver(@NotNull List typeParameters, @NotNull DeclarationDescriptor owner) { - this.typeParameters = typeParameters; - this.owner = owner; - - assert parametersBelongToOwner() : "Type parameters should belong to owner: " + owner + "; " + typeParameters; - } - - private boolean parametersBelongToOwner() { - for (TypeParameterDescriptor typeParameter : typeParameters) { - if (typeParameter.getContainingDeclaration() != owner) { - return false; - } +public interface TypeVariableResolver { + TypeVariableResolver EMPTY = new TypeVariableResolver() { + @Nullable + @Override + public TypeParameterDescriptor getTypeVariable(@NotNull Name name) { + return null; } - return true; - } + }; - @NotNull - public TypeParameterDescriptor getTypeVariable(@NotNull Name name) { - return getTypeVariable(name, typeParameters, owner); - } - - @NotNull - private static TypeParameterDescriptor getTypeVariable( - @NotNull Name name, - @NotNull List typeParameters, - @NotNull DeclarationDescriptor owner - ) { - for (TypeParameterDescriptor typeParameter : typeParameters) { - if (typeParameter.getName().equals(name)) { - return typeParameter; - } - } - - DeclarationDescriptor container = owner.getContainingDeclaration(); - if (container instanceof ClassDescriptor) { - return getTypeVariable(name, ((ClassDescriptor) container).getTypeConstructor().getParameters(), container); - } - - throw new IllegalStateException("Type parameter not found by name: " + name); - } + @Nullable + TypeParameterDescriptor getTypeVariable(@NotNull Name name); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java new file mode 100644 index 00000000000..a94fa90b384 --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolverImpl.java @@ -0,0 +1,75 @@ +/* + * Copyright 2010-2013 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.resolver; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +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 TypeVariableResolverImpl implements TypeVariableResolver { + @NotNull + private final List typeParameters; + @NotNull + private final DeclarationDescriptor owner; + + public TypeVariableResolverImpl(@NotNull List typeParameters, @NotNull DeclarationDescriptor owner) { + this.typeParameters = typeParameters; + this.owner = owner; + + assert parametersBelongToOwner() : "Type parameters should belong to owner: " + owner + "; " + typeParameters; + } + + private boolean parametersBelongToOwner() { + for (TypeParameterDescriptor typeParameter : typeParameters) { + if (typeParameter.getContainingDeclaration() != owner) { + return false; + } + } + return true; + } + + @Nullable + @Override + public TypeParameterDescriptor getTypeVariable(@NotNull Name name) { + return getTypeVariable(name, typeParameters, owner); + } + + @Nullable + private static TypeParameterDescriptor getTypeVariable( + @NotNull Name name, + @NotNull List typeParameters, + @NotNull DeclarationDescriptor owner + ) { + for (TypeParameterDescriptor typeParameter : typeParameters) { + if (typeParameter.getName().equals(name)) { + return typeParameter; + } + } + + DeclarationDescriptor container = owner.getContainingDeclaration(); + if (container instanceof ClassDescriptor) { + return getTypeVariable(name, ((ClassDescriptor) container).getTypeConstructor().getParameters(), container); + } + + return null; + } +}