diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java index 17b4530054b..4d46a256cb9 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java @@ -39,10 +39,7 @@ import org.jetbrains.kotlin.types.Variance; import org.jetbrains.kotlin.types.checker.KotlinTypeChecker; import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import static org.jetbrains.kotlin.load.java.components.TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT; import static org.jetbrains.kotlin.load.java.components.TypeUsage.UPPER_BOUND; @@ -253,7 +250,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD TypeParameterDescriptorImpl altParamDescriptor = originalToAltTypeParameters.get(originalTypeParamDescriptor); KtTypeParameter altTypeParameter = altFunDeclaration.getTypeParameters().get(i); - Set originalUpperBounds = originalTypeParamDescriptor.getUpperBounds(); + List originalUpperBounds = originalTypeParamDescriptor.getUpperBounds(); List altUpperBounds = getUpperBounds(altFunDeclaration, altTypeParameter); if (altUpperBounds.size() != originalUpperBounds.size()) { if (altUpperBounds.isEmpty() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java index 2100dca52a2..98cf6595de9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors; -import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor; import org.jetbrains.kotlin.lexer.KtTokens; @@ -28,44 +27,44 @@ import org.jetbrains.kotlin.resolve.lazy.LazyEntity; import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt; import org.jetbrains.kotlin.types.KotlinType; -import java.util.Set; +import java.util.ArrayList; +import java.util.List; public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescriptor implements LazyEntity { private final LazyClassContext c; - - private final KtTypeParameter jetTypeParameter; + private final KtTypeParameter typeParameter; public LazyTypeParameterDescriptor( @NotNull LazyClassContext c, @NotNull LazyClassDescriptor containingDeclaration, - @NotNull KtTypeParameter jetTypeParameter, - int index) { + @NotNull KtTypeParameter typeParameter, + int index + ) { super( c.getStorageManager(), containingDeclaration, - jetTypeParameter.getNameAsSafeName(), - jetTypeParameter.getVariance(), - jetTypeParameter.hasModifier(KtTokens.REIFIED_KEYWORD), + typeParameter.getNameAsSafeName(), + typeParameter.getVariance(), + typeParameter.hasModifier(KtTokens.REIFIED_KEYWORD), index, - KotlinSourceElementKt.toSourceElement(jetTypeParameter) + KotlinSourceElementKt.toSourceElement(typeParameter) ); this.c = c; - this.jetTypeParameter = jetTypeParameter; + this.typeParameter = typeParameter; - this.c.getTrace().record(BindingContext.TYPE_PARAMETER, jetTypeParameter, this); + this.c.getTrace().record(BindingContext.TYPE_PARAMETER, typeParameter, this); } @NotNull @Override - protected Set resolveUpperBounds() { - Set upperBounds = Sets.newLinkedHashSet(); + protected List resolveUpperBounds() { + List upperBounds = new ArrayList(1); - KtTypeParameter jetTypeParameter = this.jetTypeParameter; - - KtTypeReference extendsBound = jetTypeParameter.getExtendsBound(); + KtTypeReference extendsBound = typeParameter.getExtendsBound(); if (extendsBound != null) { KotlinType boundType = c.getDescriptorResolver().resolveTypeParameterExtendsBound( - this, extendsBound, getContainingDeclaration().getScopeForClassHeaderResolution(), c.getTrace()); + this, extendsBound, getContainingDeclaration().getScopeForClassHeaderResolution(), c.getTrace() + ); upperBounds.add(boundType); } @@ -78,32 +77,30 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri return upperBounds; } - private void resolveUpperBoundsFromWhereClause(Set upperBounds) { - KtClassOrObject classOrObject = KtStubbedPsiUtil.getPsiOrStubParent(jetTypeParameter, KtClassOrObject.class, true); + private void resolveUpperBoundsFromWhereClause(@NotNull List upperBounds) { + KtClassOrObject classOrObject = KtStubbedPsiUtil.getPsiOrStubParent(typeParameter, KtClassOrObject.class, true); if (classOrObject instanceof KtClass) { - KtClass ktClass = (KtClass) classOrObject; - for (KtTypeConstraint jetTypeConstraint : ktClass.getTypeConstraints()) { - KtSimpleNameExpression constrainedParameterName = jetTypeConstraint.getSubjectTypeParameterName(); + for (KtTypeConstraint typeConstraint : classOrObject.getTypeConstraints()) { + KtSimpleNameExpression constrainedParameterName = typeConstraint.getSubjectTypeParameterName(); if (constrainedParameterName != null) { if (getName().equals(constrainedParameterName.getReferencedNameAsName())) { c.getTrace().record(BindingContext.REFERENCE_TARGET, constrainedParameterName, this); - KtTypeReference boundTypeReference = jetTypeConstraint.getBoundTypeReference(); + KtTypeReference boundTypeReference = typeConstraint.getBoundTypeReference(); if (boundTypeReference != null) { - KotlinType boundType = resolveBoundType(boundTypeReference); - upperBounds.add(boundType); + upperBounds.add(resolveBoundType(boundTypeReference)); } } } } } - } + @NotNull private KotlinType resolveBoundType(@NotNull KtTypeReference boundTypeReference) { - return c.getTypeResolver() - .resolveType(getContainingDeclaration().getScopeForClassHeaderResolution(), boundTypeReference, - c.getTrace(), false); + return c.getTypeResolver().resolveType( + getContainingDeclaration().getScopeForClassHeaderResolution(), boundTypeReference, c.getTrace(), false + ); } @NotNull diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java index f1988fe8bc5..81bf9a6f50f 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java @@ -34,7 +34,10 @@ import org.jetbrains.kotlin.utils.Interner; import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.util.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry; @@ -414,7 +417,7 @@ public class DescriptorSerializer { } extension.serializeTypeParameter(typeParameter, builder); - Set upperBounds = typeParameter.getUpperBounds(); + List upperBounds = typeParameter.getUpperBounds(); if (upperBounds.size() == 1 && KotlinBuiltIns.isDefaultBound(CollectionsKt.single(upperBounds))) return builder; for (KotlinType upperBound : upperBounds) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt index 07ea6058c25..d4cf51e870b 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaTypeParameterDescriptor.kt @@ -16,19 +16,16 @@ package org.jetbrains.kotlin.load.java.lazy.descriptors -import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.types.Variance -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter -import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor +import org.jetbrains.kotlin.descriptors.SourceElement +import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor import org.jetbrains.kotlin.load.java.components.TypeUsage import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext -import org.jetbrains.kotlin.load.java.lazy.types.toAttributes -import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.load.java.lazy.types.LazyJavaTypeResolver -import org.jetbrains.kotlin.load.java.lazy.types.toFlexible +import org.jetbrains.kotlin.load.java.lazy.types.toAttributes +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.Variance class LazyJavaTypeParameterDescriptor( private val c: LazyJavaResolverContext, @@ -38,26 +35,23 @@ class LazyJavaTypeParameterDescriptor( ) : AbstractLazyTypeParameterDescriptor( c.storageManager, containingDeclaration, - javaTypeParameter.getName(), + javaTypeParameter.name, Variance.INVARIANT, /* isReified = */ false, index, SourceElement.NO_SOURCE ) { - override fun resolveUpperBounds(): Set { - val bounds = javaTypeParameter.getUpperBounds() + override fun resolveUpperBounds(): List { + val bounds = javaTypeParameter.upperBounds if (bounds.isEmpty()) { - return setOf(LazyJavaTypeResolver.FlexibleJavaClassifierTypeCapabilities.create( - c.module.builtIns.getAnyType(), - c.module.builtIns.getNullableAnyType() + return listOf(LazyJavaTypeResolver.FlexibleJavaClassifierTypeCapabilities.create( + c.module.builtIns.anyType, + c.module.builtIns.nullableAnyType )) } - else { - return bounds.map { - javaType -> c.typeResolver.transformJavaType(javaType, TypeUsage.UPPER_BOUND.toAttributes(upperBoundForTypeParameter = this)) - }.toSet() + return bounds.map { + c.typeResolver.transformJavaType(it, TypeUsage.UPPER_BOUND.toAttributes(upperBoundForTypeParameter = this)) } } - } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java index aaaaff820c4..c0b29e7433f 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/TypeParameterDescriptor.java @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.types.TypeConstructor; import org.jetbrains.kotlin.types.TypeSubstitutor; import org.jetbrains.kotlin.types.Variance; -import java.util.Set; +import java.util.List; public interface TypeParameterDescriptor extends ClassifierDescriptor { boolean isReified(); @@ -31,13 +31,13 @@ public interface TypeParameterDescriptor extends ClassifierDescriptor { Variance getVariance(); @NotNull - Set getUpperBounds(); + List getUpperBounds(); @NotNull KotlinType getUpperBoundsAsType(); @NotNull - Set getLowerBounds(); + List getLowerBounds(); @NotNull @Override diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java index 5346236a760..c2fbdbce1b4 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java @@ -33,18 +33,21 @@ import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.checker.KotlinTypeChecker; import java.util.Collections; -import java.util.Set; +import java.util.List; import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getBuiltIns; public abstract class AbstractTypeParameterDescriptor extends DeclarationDescriptorNonRootImpl implements TypeParameterDescriptor { + public static final List FALLBACK_UPPER_BOUNDS_ON_RECURSION = + Collections.singletonList(ErrorUtils.createErrorType("Recursion while calculating upper bounds")); + private final Variance variance; private final boolean reified; private final int index; private final NotNullLazyValue typeConstructor; private final NotNullLazyValue defaultType; - private final NotNullLazyValue> upperBounds; + private final NotNullLazyValue> upperBounds; private final NotNullLazyValue upperBoundsAsType; protected AbstractTypeParameterDescriptor( @@ -71,23 +74,26 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip this.defaultType = storageManager.createLazyValue(new Function0() { @Override public KotlinType invoke() { - return KotlinTypeImpl.create(Annotations.Companion.getEMPTY(), getTypeConstructor(), false, Collections.emptyList(), - new LazyScopeAdapter(storageManager.createLazyValue( - new Function0() { - @Override - public KtScope invoke() { - return getUpperBoundsAsType().getMemberScope(); - } - } - ))); + return KotlinTypeImpl.create( + Annotations.Companion.getEMPTY(), + getTypeConstructor(), false, Collections.emptyList(), + new LazyScopeAdapter(storageManager.createLazyValue( + new Function0() { + @Override + public KtScope invoke() { + return getUpperBoundsAsType().getMemberScope(); + } + } + )) + ); } }); - this.upperBounds = storageManager.createRecursionTolerantLazyValue(new Function0>() { + this.upperBounds = storageManager.createRecursionTolerantLazyValue(new Function0>() { @Override - public Set invoke() { + public List invoke() { return resolveUpperBounds(); } - }, Collections.singleton(ErrorUtils.createErrorType("Recursion while calculating upper bounds"))); + }, FALLBACK_UPPER_BOUNDS_ON_RECURSION); this.upperBoundsAsType = storageManager.createLazyValue(new Function0() { @Override public KotlinType invoke() { @@ -97,8 +103,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip } @NotNull - @ReadOnly - protected abstract Set resolveUpperBounds(); + protected abstract List resolveUpperBounds(); @NotNull protected abstract TypeConstructor createTypeConstructor(); @@ -121,7 +126,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip @NotNull @Override - public Set getUpperBounds() { + public List getUpperBounds() { return upperBounds.invoke(); } @@ -133,7 +138,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip @NotNull private KotlinType computeUpperBoundsAsType() { - Set upperBounds = getUpperBounds(); + List upperBounds = getUpperBounds(); assert !upperBounds.isEmpty() : "Upper bound list is empty in " + getName(); KotlinType upperBoundsAsType = TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, upperBounds); return upperBoundsAsType != null ? upperBoundsAsType : getBuiltIns(this).getNothingType(); @@ -153,8 +158,8 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip @NotNull @Override - public Set getLowerBounds() { - return Collections.singleton(getBuiltIns(this).getNothingType()); + public List getLowerBounds() { + return Collections.singletonList(getBuiltIns(this).getNothingType()); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java index 5cc2badc3f7..2d8e3ad42dd 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/TypeParameterDescriptorImpl.java @@ -28,10 +28,10 @@ import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.TypeConstructor; import org.jetbrains.kotlin.types.TypeConstructorImpl; import org.jetbrains.kotlin.types.Variance; -import org.jetbrains.kotlin.utils.SmartSet; +import java.util.ArrayList; import java.util.Collections; -import java.util.Set; +import java.util.List; import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getBuiltIns; @@ -63,7 +63,7 @@ public class TypeParameterDescriptorImpl extends AbstractTypeParameterDescriptor return new TypeParameterDescriptorImpl(containingDeclaration, annotations, reified, variance, name, index, source); } - private final Set upperBounds = SmartSet.create(); + private final List upperBounds = new ArrayList(1); private boolean initialized = false; private TypeParameterDescriptorImpl( @@ -132,7 +132,7 @@ public class TypeParameterDescriptorImpl extends AbstractTypeParameterDescriptor @NotNull @Override - protected Set resolveUpperBounds() { + protected List resolveUpperBounds() { checkInitialized(); return upperBounds; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java b/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java index 2a9b2a47a76..8b95525aa36 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/DescriptorSubstitutor.java @@ -53,7 +53,6 @@ public class DescriptorSubstitutor { index++, SourceElement.NO_SOURCE ); - substituted.setInitialized(); mutableSubstitution.put(descriptor.getTypeConstructor(), new TypeProjectionImpl(substituted.getDefaultType())); @@ -68,8 +67,11 @@ public class DescriptorSubstitutor { for (TypeParameterDescriptor descriptor : typeParameters) { TypeParameterDescriptorImpl substituted = substitutedMap.get(descriptor); for (KotlinType upperBound : descriptor.getUpperBounds()) { - substituted.getUpperBounds().add(substitutor.substitute(upperBound, Variance.INVARIANT)); + KotlinType substitutedBound = substitutor.substitute(upperBound, Variance.INVARIANT); + assert substitutedBound != null : "Upper bound failed to substitute: " + descriptor; + substituted.addUpperBound(substitutedBound); } + substituted.setInitialized(); } return substitutor; diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java index 03a04a702e5..49e9abacab1 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeIntersector.java @@ -42,11 +42,8 @@ public class TypeIntersector { } @Nullable - public static KotlinType intersectTypes( - @NotNull KotlinTypeChecker typeChecker, - @NotNull Set types - ) { - assert (!types.isEmpty()) : "Attempting to intersect empty set of types, this case should be dealt with on the call site."; + public static KotlinType intersectTypes(@NotNull KotlinTypeChecker typeChecker, @NotNull Collection types) { + assert !types.isEmpty() : "Attempting to intersect empty collection of types, this case should be dealt with on the call site."; if (types.size() == 1) { return types.iterator().next(); @@ -73,7 +70,7 @@ public class TypeIntersector { if (nullabilityStripped.isEmpty()) { // All types were errors - return ErrorUtils.createErrorType("Intersection of errors types: " + types); + return ErrorUtils.createErrorType("Intersection of error types: " + types); } // Now we remove types that have subtypes in the list @@ -95,7 +92,6 @@ public class TypeIntersector { if (!type.equals(other) && typeChecker.isSubtypeOf(other, type)) { continue outer; } - } } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt index 940302c4e08..6ed44f6fc89 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedTypeParameterDescriptor.kt @@ -22,15 +22,19 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.serialization.ProtoBuf -import org.jetbrains.kotlin.serialization.deserialization.* +import org.jetbrains.kotlin.serialization.deserialization.Deserialization +import org.jetbrains.kotlin.serialization.deserialization.DeserializationContext +import org.jetbrains.kotlin.serialization.deserialization.upperBounds import org.jetbrains.kotlin.types.KotlinType -import java.util.* class DeserializedTypeParameterDescriptor( - c: DeserializationContext, private val proto: ProtoBuf.TypeParameter, index: Int) : AbstractLazyTypeParameterDescriptor(c.storageManager, c.containingDeclaration, c.nameResolver.getName(proto.name), Deserialization.variance(proto.variance), proto.reified, index, SourceElement.NO_SOURCE) { - private val typeDeserializer: TypeDeserializer = c.typeDeserializer - private val typeTable: TypeTable = c.typeTable - + private val c: DeserializationContext, + private val proto: ProtoBuf.TypeParameter, + index: Int +) : AbstractLazyTypeParameterDescriptor( + c.storageManager, c.containingDeclaration, c.nameResolver.getName(proto.name), + Deserialization.variance(proto.variance), proto.reified, index, SourceElement.NO_SOURCE +) { private val annotations = DeserializedAnnotationsWithPossibleTargets(c.storageManager) { c.components.annotationAndConstantLoader .loadTypeParameterAnnotations(proto, c.nameResolver) @@ -39,15 +43,13 @@ class DeserializedTypeParameterDescriptor( override fun getAnnotations(): Annotations = annotations - override fun resolveUpperBounds(): Set { - val upperBounds = proto.upperBounds(typeTable) + override fun resolveUpperBounds(): List { + val upperBounds = proto.upperBounds(c.typeTable) if (upperBounds.isEmpty()) { - return setOf(this.builtIns.getDefaultBound()) + return listOf(this.builtIns.defaultBound) } - val result = LinkedHashSet(upperBounds.size()) - for (upperBound in upperBounds) { - result.add(typeDeserializer.type(upperBound, Annotations.EMPTY)) + return upperBounds.map { + c.typeDeserializer.type(it, Annotations.EMPTY) } - return result } }