From 460c71975339b5b7707eaaa00ee6813bab671c3e Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Mon, 3 Aug 2015 17:55:00 +0300 Subject: [PATCH] Make constructor of JetTypeImpl private, introduce factory methods --- .../codegen/CollectionStubMethodGenerator.kt | 3 +- .../java/sam/SingleAbstractMethodUtils.java | 2 +- .../PropagationHeuristics.java | 2 +- .../SignaturesPropagationData.java | 2 +- .../TypeTransformingVisitor.java | 3 +- .../jetbrains/kotlin/resolve/TypeResolver.kt | 4 +- .../kotlin/resolve/calls/CallResolverUtil.kt | 4 +- .../BasicExpressionTypingVisitor.java | 2 +- .../ConstraintSystemTestData.kt | 5 ++- .../descriptors/LazyJavaClassDescriptor.kt | 7 ++- .../java/lazy/types/LazyJavaTypeResolver.kt | 4 +- .../java/typeEnhacement/typeEnhancement.kt | 2 +- .../kotlin/builtins/KotlinBuiltIns.java | 17 +++---- .../kotlin/builtins/ReflectionTypes.kt | 6 +-- .../functions/FunctionClassDescriptor.kt | 2 +- .../impl/AbstractTypeParameterDescriptor.java | 2 +- .../impl/LazySubstitutingClassDescriptor.java | 8 ++-- .../inference/CapturedTypeConstructor.kt | 2 +- .../calls/inference/ConstraintSystemImpl.kt | 4 +- .../resolve/constants/CompileTimeConstant.kt | 2 +- .../kotlin/types/CapturedTypeApproximation.kt | 4 +- .../kotlin/types/CommonSupertypes.java | 2 +- .../org/jetbrains/kotlin/types/JetTypeImpl.kt | 45 +++++++++++++++---- .../kotlin/types/TypeSubstitutor.java | 6 +-- .../org/jetbrains/kotlin/types/TypeUtils.java | 4 +- .../jetbrains/kotlin/idea/util/TypeUtils.kt | 2 +- .../smart/TypeInstantiationItems.kt | 5 +-- .../callableBuilder/typeUtils.kt | 2 +- .../CreateIteratorFunctionActionFactory.kt | 2 +- 29 files changed, 90 insertions(+), 65 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt index c9439ba3204..ffeed167bf9 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt @@ -209,8 +209,7 @@ class CollectionStubMethodGenerator( } private fun newType(classDescriptor: ClassDescriptor, typeArguments: List): JetType { - return JetTypeImpl(Annotations.EMPTY, classDescriptor.getTypeConstructor(), false, typeArguments, - classDescriptor.getMemberScope(typeArguments)) + return JetTypeImpl.create(Annotations.EMPTY, classDescriptor, false, typeArguments) } private fun FunctionDescriptor.signature(): JvmMethodSignature = typeMapper.mapSignature(this) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java index c64949ef4af..0f90b74fefa 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java @@ -76,7 +76,7 @@ public class SingleAbstractMethodUtils { } ClassifierDescriptor classifier = functionType.getConstructor().getDeclarationDescriptor(); assert classifier instanceof ClassDescriptor : "Not class: " + classifier; - return new JetTypeImpl( + return JetTypeImpl.create( functionType.getAnnotations(), functionType.getConstructor(), functionType.isMarkedNullable(), diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java index e7ce5690621..14af923fc98 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/PropagationHeuristics.java @@ -61,7 +61,7 @@ class PropagationHeuristics { if (JetTypeChecker.DEFAULT.isSubtypeOf(elementType, elementTypeInSuper) && !JetTypeChecker.DEFAULT.equalTypes(elementType, elementTypeInSuper)) { - JetTypeImpl betterTypeInSuper = new JetTypeImpl( + JetTypeImpl betterTypeInSuper = JetTypeImpl.create( arrayTypeFromSuper.getAnnotations(), arrayTypeFromSuper.getConstructor(), arrayTypeFromSuper.isMarkedNullable(), diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java index 5a4e45f5780..c9c6c6fed9e 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java @@ -407,7 +407,7 @@ public class SignaturesPropagationData { resultScope = autoType.getMemberScope(); } - JetTypeImpl type = new JetTypeImpl(autoType.getAnnotations(), + JetType type = JetTypeImpl.create(autoType.getAnnotations(), resultClassifier.getTypeConstructor(), resultNullable, resultArguments, diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java index fa0900556a7..f9563f90adf 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/TypeTransformingVisitor.java @@ -157,8 +157,7 @@ public class TypeTransformingVisitor extends JetVisitor { throw new AssertionError("Unexpected class of type constructor classifier " + (typeConstructorClassifier == null ? "null" : typeConstructorClassifier.getClass().getName())); } - return new JetTypeImpl(originalType.getAnnotations(), typeConstructor, false, - altArguments, memberScope); + return JetTypeImpl.create(originalType.getAnnotations(), typeConstructor, false, altArguments, memberScope); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt index ef7dc7b89e3..258a8aa2a4d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt @@ -137,7 +137,7 @@ public class TypeResolver( result = if (scopeForTypeParameter is ErrorUtils.ErrorScope) type(ErrorUtils.createErrorType("?")) else - type(JetTypeImpl( + type(JetTypeImpl.create( annotations, classifierDescriptor.getTypeConstructor(), TypeUtils.hasNullableLowerBound(classifierDescriptor), @@ -191,7 +191,7 @@ public class TypeResolver( ) return } - val resultingType = JetTypeImpl(annotations, typeConstructor, false, arguments, classifierDescriptor.getMemberScope(arguments)) + val resultingType = JetTypeImpl.create(annotations, classifierDescriptor, false, arguments) result = type(resultingType) if (c.checkBounds) { val substitutor = TypeSubstitutor.create(resultingType) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt index 33ce2e7af7b..abd936a2340 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt @@ -64,7 +64,7 @@ public fun replaceReturnTypeByUnknown(type: JetType): JetType { } private fun replaceTypeArguments(type: JetType, newArguments: List) = - JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope()) + JetTypeImpl.create(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope()) private fun getParameterArgumentsOfCallableType(type: JetType) = type.getArguments().dropLast(1) @@ -100,7 +100,7 @@ public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterD for (typeProjection in receiverType.getArguments()) { fakeTypeArguments.add(TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE)) } - return JetTypeImpl(receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), fakeTypeArguments, + return JetTypeImpl.create(receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), fakeTypeArguments, ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true)) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 235cef21896..04b24c18f0d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -578,7 +578,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } }); - return new JetTypeImpl(Annotations.EMPTY, typeConstructor, false, arguments, descriptor.getMemberScope(arguments)); + return JetTypeImpl.create(Annotations.EMPTY, descriptor, false, arguments); } private static boolean isAllowedInClassLiteral(@NotNull JetType type) { diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt index b8abff965a9..34b87add793 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt +++ b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestData.kt @@ -60,7 +60,10 @@ public class ConstraintSystemTestData( val matcher = INTEGER_VALUE_TYPE_PATTERN.matcher(name) if (matcher.find()) { val number = matcher.group(1)!! - return JetTypeImpl(Annotations.EMPTY, IntegerValueTypeConstructor(number.toLong(), KotlinBuiltIns.getInstance()), false, listOf(), JetScope.Empty) + return JetTypeImpl.create( + Annotations.EMPTY, IntegerValueTypeConstructor(number.toLong(), KotlinBuiltIns.getInstance()), false, listOf(), + JetScope.Empty + ) } return typeResolver.resolveType( scopeToResolveTypeParameters, JetPsiFactory(project).createType(name), diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt index b3ef57e12a4..fa90696a535 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt @@ -168,10 +168,9 @@ class LazyJavaClassDescriptor( parameter -> TypeProjectionImpl(Variance.INVARIANT, parameter.getDefaultType()) } - return JetTypeImpl( - Annotations.EMPTY, classDescriptor.getTypeConstructor(), - /* nullable =*/ false, parametersAsTypeProjections, - classDescriptor.getMemberScope(parametersAsTypeProjections) + return JetTypeImpl.create( + Annotations.EMPTY, classDescriptor, + /* nullable =*/ false, parametersAsTypeProjections ) } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt index 03402fc4392..fc5782771fb 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt @@ -289,14 +289,14 @@ class LazyJavaTypeResolver( val arguments = listOf( TypeProjectionImpl(componentTypeProjection.projectionKind, eraseType(componentTypeProjection.type)) ) - return JetTypeImpl( + return JetTypeImpl.create( type.annotations, type.constructor, type.isMarkedNullable, arguments, (type.constructor.declarationDescriptor as ClassDescriptor).getMemberScope(arguments) ) } val constructor = type.constructor - return JetTypeImpl( + return JetTypeImpl.create( type.annotations, constructor, type.isMarkedNullable, type.constructor.parameters.map { parameter -> computeProjection(parameter, attr) diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt index 1d66d433c50..5c58e129030 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt @@ -102,7 +102,7 @@ private fun JetType.enhanceInflexible(qualifiers: (Int) -> JavaTypeQualifiers, i typeConstructor.parameters, enhancedArguments ) - val enhancedType = JetTypeImpl( + val enhancedType = JetTypeImpl.create( newAnnotations, typeConstructor, enhancedNullability, diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index 4688411d9e2..720ab7c77a9 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java @@ -664,12 +664,11 @@ public class KotlinBuiltIns { @NotNull public JetType getArrayType(@NotNull Variance projectionType, @NotNull JetType argument) { List types = Collections.singletonList(new TypeProjectionImpl(projectionType, argument)); - return new JetTypeImpl( + return JetTypeImpl.create( Annotations.EMPTY, - getArray().getTypeConstructor(), + getArray(), false, - types, - getArray().getMemberScope(types) + types ); } @@ -677,12 +676,11 @@ public class KotlinBuiltIns { public JetType getEnumType(@NotNull JetType argument) { Variance projectionType = Variance.INVARIANT; List types = Collections.singletonList(new TypeProjectionImpl(projectionType, argument)); - return new JetTypeImpl( + return JetTypeImpl.create( Annotations.EMPTY, - getEnum().getTypeConstructor(), + getEnum(), false, - types, - getEnum().getMemberScope(types) + types ); } @@ -721,11 +719,10 @@ public class KotlinBuiltIns { List arguments = getFunctionTypeArgumentProjections(receiverType, parameterTypes, returnType); int size = parameterTypes.size(); ClassDescriptor classDescriptor = receiverType == null ? getFunction(size) : getExtensionFunction(size); - TypeConstructor constructor = classDescriptor.getTypeConstructor(); Annotations typeAnnotations = receiverType == null ? annotations : addExtensionAnnotation(annotations); - return new JetTypeImpl(typeAnnotations, constructor, false, arguments, classDescriptor.getMemberScope(arguments)); + return JetTypeImpl.create(typeAnnotations, classDescriptor, false, arguments); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt index 449d0ffa3a9..f7234e635ba 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/ReflectionTypes.kt @@ -63,7 +63,7 @@ public class ReflectionTypes(private val module: ModuleDescriptor) { } val arguments = listOf(TypeProjectionImpl(Variance.INVARIANT, type)) - return JetTypeImpl(annotations, descriptor.getTypeConstructor(), false, arguments, descriptor.getMemberScope(arguments)) + return JetTypeImpl.create(annotations, descriptor, false, arguments) } public fun getKFunctionType( @@ -80,7 +80,7 @@ public class ReflectionTypes(private val module: ModuleDescriptor) { return classDescriptor.getDefaultType() } - return JetTypeImpl(annotations, classDescriptor.getTypeConstructor(), false, arguments, classDescriptor.getMemberScope(arguments)) + return JetTypeImpl.create(annotations, classDescriptor, false, arguments) } public fun getKPropertyType(annotations: Annotations, receiverType: JetType?, returnType: JetType, mutable: Boolean): JetType { @@ -105,7 +105,7 @@ public class ReflectionTypes(private val module: ModuleDescriptor) { arguments.add(TypeProjectionImpl(receiverType)) } arguments.add(TypeProjectionImpl(returnType)) - return JetTypeImpl(annotations, classDescriptor.getTypeConstructor(), false, arguments, classDescriptor.getMemberScope(arguments)) + return JetTypeImpl.create(annotations, classDescriptor, false, arguments) } companion object { diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt index 5b013d923de..ae9b1ecdecd 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt @@ -119,7 +119,7 @@ public class FunctionClassDescriptor( TypeProjectionImpl(it.getDefaultType()) } - result.add(JetTypeImpl(Annotations.EMPTY, typeConstructor, false, arguments, descriptor.getMemberScope(arguments))) + result.add(JetTypeImpl.create(Annotations.EMPTY, descriptor, false, arguments)) } // Add unnumbered base class, e.g. Function for Function{n}, KFunction for KFunction{n} 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 6a094e436d2..59e11428c9b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/AbstractTypeParameterDescriptor.java @@ -71,7 +71,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip this.defaultType = storageManager.createLazyValue(new Function0() { @Override public JetType invoke() { - return new JetTypeImpl(Annotations.EMPTY, getTypeConstructor(), false, Collections.emptyList(), + return JetTypeImpl.create(Annotations.EMPTY, getTypeConstructor(), false, Collections.emptyList(), new LazyScopeAdapter(storageManager.createLazyValue( new Function0() { @Override diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java index 178860982c3..a754ce0cb2a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java @@ -127,12 +127,12 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor { @Override public JetType getDefaultType() { List typeProjections = TypeUtils.getDefaultTypeProjections(getTypeConstructor().getParameters()); - return new JetTypeImpl( + return JetTypeImpl.create( getAnnotations(), - getTypeConstructor(), + this, false, - typeProjections, - getMemberScope(typeProjections)); + typeProjections + ); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt index bd13f56f4ea..c75aa2ca00c 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/CapturedTypeConstructor.kt @@ -60,7 +60,7 @@ public class CapturedType( private val delegateType = run { val scope = ErrorUtils.createErrorScope( "No member resolution should be done on captured type, it used only during constraint system resolution", true) - JetTypeImpl(Annotations.EMPTY, CapturedTypeConstructor(typeProjection), false, listOf(), scope) + JetTypeImpl.create(Annotations.EMPTY, CapturedTypeConstructor(typeProjection), false, listOf(), scope) } override fun getDelegate(): JetType = delegateType diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt index d3812434118..3a19fec8e89 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt @@ -161,7 +161,7 @@ public class ConstraintSystemImpl : ConstraintSystem { val TypeParameterDescriptor.correspondingType: JetType get() = cachedTypeForVariable.getOrPut(this) { - JetTypeImpl(Annotations.EMPTY, this.getTypeConstructor(), false, listOf(), JetScope.Empty) + JetTypeImpl.create(Annotations.EMPTY, this.getTypeConstructor(), false, listOf(), JetScope.Empty) } fun JetType.isProper() = !TypeUtils.containsSpecialType(this) { @@ -548,7 +548,7 @@ public fun createTypeSubstitutor(conversion: (TypeParameterDescriptor) -> TypePa if (descriptor !is TypeParameterDescriptor) return null val typeParameterDescriptor = conversion(descriptor) ?: return null - val type = JetTypeImpl(Annotations.EMPTY, typeParameterDescriptor.getTypeConstructor(), false, listOf(), JetScope.Empty) + val type = JetTypeImpl.create(Annotations.EMPTY, typeParameterDescriptor.getTypeConstructor(), false, listOf(), JetScope.Empty) return TypeProjectionImpl(type) } }) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt index d1d409af2f9..7413ae0eb5d 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt @@ -81,7 +81,7 @@ public class IntegerValueTypeConstant( } } - val unknownIntegerType = JetTypeImpl( + val unknownIntegerType = JetTypeImpl.create( Annotations.EMPTY, typeConstructor, false, emptyList(), ErrorUtils.createErrorScope("Scope for number value type (" + typeConstructor.toString() + ")", true) ) diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt b/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt index 93801aa2fa9..f24f778f36f 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/CapturedTypeApproximation.kt @@ -120,7 +120,9 @@ public fun approximateCapturedTypes(type: JetType): ApproximationBounds private fun JetType.replaceTypeArguments(newTypeArguments: List): JetType { assert(getArguments().size() == newTypeArguments.size()) { "Incorrect type arguments $newTypeArguments" } - return JetTypeImpl(getAnnotations(), getConstructor(), isMarkedNullable(), newTypeArguments.map { it.toTypeProjection() }, getMemberScope()) + return JetTypeImpl.create( + getAnnotations(), getConstructor(), isMarkedNullable(), newTypeArguments.map { it.toTypeProjection() }, getMemberScope() + ) } private fun approximateProjection(typeArgument: TypeArgument): ApproximationBounds { diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java b/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java index 0cf2248b135..7460747c43c 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/CommonSupertypes.java @@ -238,7 +238,7 @@ public class CommonSupertypes { else { newScope = ErrorUtils.createErrorScope("A scope for common supertype which is not a normal classifier", true); } - return new JetTypeImpl(Annotations.EMPTY, constructor, nullable, newProjections, newScope); + return JetTypeImpl.create(Annotations.EMPTY, constructor, nullable, newProjections, newScope); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/JetTypeImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/types/JetTypeImpl.kt index 6bd93d51dc4..a14aa8a71f1 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/JetTypeImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/JetTypeImpl.kt @@ -16,10 +16,13 @@ package org.jetbrains.kotlin.types +import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.resolve.scopes.JetScope +import kotlin.platform.platformStatic -public class JetTypeImpl( +public class JetTypeImpl +private constructor( private val annotations: Annotations, private val constructor: TypeConstructor, private val nullable: Boolean, @@ -27,20 +30,44 @@ public class JetTypeImpl( private val substitution: TypeSubstitution?, private val memberScope: JetScope ) : AbstractJetType() { + + companion object { + @platformStatic + public fun create(annotations: Annotations, + constructor: TypeConstructor, + nullable: Boolean, + arguments: List, + memberScope: JetScope): JetTypeImpl + + = JetTypeImpl(annotations, constructor, nullable, arguments, null, memberScope) + + @platformStatic + public fun create(annotations: Annotations, + constructor: TypeConstructor, + nullable: Boolean, + arguments: List, + substitution: TypeSubstitution, + memberScope: JetScope): JetTypeImpl + + = JetTypeImpl(annotations, constructor, nullable, arguments, substitution, memberScope) + + @platformStatic + public fun create(annotations: Annotations, + descriptor: ClassDescriptor, + nullable: Boolean, + arguments: List): JetTypeImpl + + = JetTypeImpl( + annotations, descriptor.typeConstructor, nullable, arguments, null, descriptor.getMemberScope(arguments) + ) + } + init { if (memberScope is ErrorUtils.ErrorScope) { throw IllegalStateException("JetTypeImpl should not be created for error type: $memberScope\n$constructor") } } - public constructor( - annotations: Annotations, - constructor: TypeConstructor, - nullable: Boolean, - arguments: List, - memberScope: JetScope - ) : this(annotations, constructor, nullable, arguments, null, memberScope) - override fun getAnnotations() = annotations override fun getSubstitution(): TypeSubstitution { diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java index 99af5c145f5..f082cf059e4 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitutor.java @@ -226,9 +226,9 @@ public class TypeSubstitutor { return substitution.isEmpty(); } }; - JetType substitutedType = new JetTypeImpl(type.getAnnotations(), // Old annotations. This is questionable - type.getConstructor(), // The same constructor - type.isMarkedNullable(), // Same nullability + JetType substitutedType = JetTypeImpl.create(type.getAnnotations(), // Old annotations. This is questionable + type.getConstructor(), // The same constructor + type.isMarkedNullable(), // Same nullability substitutedArguments, new SubstitutingScope(type.getMemberScope(), create(substitutionFilteringTypeParameters))); return new TypeProjectionImpl(projectionKind, substitutedType); diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java index 88200e47d0d..87e9dc5a256 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.java @@ -259,7 +259,7 @@ public class TypeUtils { i++; } - return new JetTypeImpl( + return JetTypeImpl.create( Annotations.EMPTY, constructor, allNullable, @@ -415,7 +415,7 @@ public class TypeUtils { } TypeConstructor typeConstructor = classDescriptor.getTypeConstructor(); List arguments = getDefaultTypeProjections(typeConstructor.getParameters()); - return new JetTypeImpl( + return JetTypeImpl.create( Annotations.EMPTY, typeConstructor, false, diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt index 4ac7a36c10b..380854cd40b 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/TypeUtils.kt @@ -57,7 +57,7 @@ public fun approximateFlexibleTypes(jetType: JetType, outermost: Boolean = true) return approximation } - return JetTypeImpl( + return JetTypeImpl.create( jetType.getAnnotations(), jetType.getConstructor(), jetType.isMarkedNullable(), diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt index 1e971bde3b7..3f1a678838a 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt @@ -265,9 +265,8 @@ class TypeInstantiationItems( val typeArgs: List, val tail: Tail?) : InheritanceItemsSearcher { - private val typeConstructor = classDescriptor.getTypeConstructor() - private val baseHasTypeArgs = typeConstructor.getParameters().isNotEmpty() - private val expectedType = JetTypeImpl(Annotations.EMPTY, typeConstructor, false, typeArgs, classDescriptor.getMemberScope(typeArgs)) + private val baseHasTypeArgs = classDescriptor.typeConstructor.parameters.isNotEmpty() + private val expectedType = JetTypeImpl.create(Annotations.EMPTY, classDescriptor, false, typeArgs) override fun search(nameFilter: (String) -> Boolean, consumer: (LookupElement) -> Unit) { val parameters = ClassInheritorsSearch.SearchParameters(psiClass, inheritorSearchScope, true, true, false, nameFilter) diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt index 008ce12f0a7..248f0747c14 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt @@ -224,7 +224,7 @@ private fun JetType.substitute(substitution: JetTypeSubstitution, variance: Vari val (projection, typeParameter) = pair TypeProjectionImpl(Variance.INVARIANT, projection.getType().substitute(substitution, typeParameter.getVariance())) } - return JetTypeImpl(getAnnotations(), getConstructor(), isMarkedNullable(), newArguments, getMemberScope()) + return JetTypeImpl.create(getAnnotations(), getConstructor(), isMarkedNullable(), newArguments, getMemberScope()) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt index c565af7553c..23582d098a2 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateIteratorFunctionActionFactory.kt @@ -50,7 +50,7 @@ object CreateIteratorFunctionActionFactory : CreateCallableMemberFromUsageFactor val returnJetTypeParameterType = TypeProjectionImpl(returnJetTypeParameterTypes[0]) val returnJetTypeArguments = Collections.singletonList(returnJetTypeParameterType) - val newReturnJetType = JetTypeImpl(returnJetType.annotations, + val newReturnJetType = JetTypeImpl.create(returnJetType.annotations, returnJetType.constructor, returnJetType.isMarkedNullable, returnJetTypeArguments,