From 5dc5d77e603ffc15a18e243bd58da690783f97ad Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Tue, 7 Jul 2015 13:34:32 +0300 Subject: [PATCH] Inject builtins in constants --- .../kotlin/codegen/AnnotationCodegen.java | 4 +-- .../codegen/JvmSerializerExtension.java | 4 ++- .../builtins/BuiltInsSerializer.kt | 2 +- .../JavaPropertyInitializerEvaluatorImpl.java | 3 ++- .../resolve/calls/CallExpressionResolver.java | 6 ++--- .../constants/CompileTimeConstantChecker.java | 4 +-- .../evaluate/ConstantExpressionEvaluator.kt | 16 ++++++------ .../BasicExpressionTypingVisitor.java | 6 ++--- .../expressions/ExpressionTypingUtils.java | 5 ++-- .../serialization/AnnotationSerializer.kt | 5 ++-- .../builtins/BuiltInsSerializerExtension.kt | 21 ++++++++-------- .../LazyJavaAnnotationDescriptor.kt | 2 +- ...aryClassAnnotationAndConstantLoaderImpl.kt | 2 +- .../resolve/constants/AnnotationValue.kt | 3 ++- .../kotlin/resolve/constants/ArrayValue.kt | 4 +-- .../kotlin/resolve/constants/BooleanValue.kt | 5 ++-- .../kotlin/resolve/constants/ByteValue.kt | 5 ++-- .../kotlin/resolve/constants/CharValue.kt | 5 ++-- .../resolve/constants/CompileTimeConstant.kt | 2 +- .../constants/CompileTimeConstantFactory.kt | 25 +++++++++++-------- .../kotlin/resolve/constants/DoubleValue.kt | 5 ++-- .../kotlin/resolve/constants/EnumValue.kt | 7 +++--- .../kotlin/resolve/constants/ErrorValue.kt | 2 +- .../kotlin/resolve/constants/FloatValue.kt | 5 ++-- .../kotlin/resolve/constants/IntValue.kt | 5 ++-- .../constants/IntegerValueTypeConstant.kt | 10 +++----- .../kotlin/resolve/constants/KClassValue.kt | 3 +-- .../kotlin/resolve/constants/LongValue.kt | 5 ++-- .../kotlin/resolve/constants/NullValue.kt | 6 +++-- .../kotlin/resolve/constants/ShortValue.kt | 5 ++-- .../kotlin/resolve/constants/StringValue.kt | 5 ++-- .../deserialization/AnnotationDeserializer.kt | 4 +-- .../js/KotlinJavascriptSerializerExtension.kt | 16 +++++++----- 33 files changed, 111 insertions(+), 96 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java index a5c3f95a6e3..fbfe87901d8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java @@ -274,7 +274,7 @@ public abstract class AnnotationCodegen { @Override public Void visitEnumValue(EnumValue value, Void data) { String propertyName = value.getValue().getName().asString(); - annotationVisitor.visitEnum(name, typeMapper.mapType(value.getType(KotlinBuiltIns.getInstance())).getDescriptor(), propertyName); + annotationVisitor.visitEnum(name, typeMapper.mapType(value.getType()).getDescriptor(), propertyName); return null; } @@ -282,7 +282,7 @@ public abstract class AnnotationCodegen { public Void visitArrayValue(ArrayValue value, Void data) { AnnotationVisitor visitor = annotationVisitor.visitArray(name); for (CompileTimeConstant argument : value.getValue()) { - genCompileTimeValue(null, argument, value.getType(KotlinBuiltIns.getInstance()), visitor); + genCompileTimeValue(null, argument, value.getType(), visitor); } visitor.visitEnd(); return null; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java index 994399eb8ed..5c30d9271c2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmSerializerExtension.java @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; @@ -45,6 +46,7 @@ import static org.jetbrains.kotlin.codegen.JvmSerializationBindings.*; public class JvmSerializerExtension extends SerializerExtension { private final JvmSerializationBindings bindings; private final JetTypeMapper typeMapper; + private final AnnotationSerializer annotationSerializer = new AnnotationSerializer(KotlinBuiltIns.getInstance()); public JvmSerializerExtension(@NotNull JvmSerializationBindings bindings, @NotNull JetTypeMapper typeMapper) { this.bindings = bindings; @@ -77,7 +79,7 @@ public class JvmSerializerExtension extends SerializerExtension { public void serializeType(@NotNull JetType type, @NotNull ProtoBuf.Type.Builder proto, @NotNull StringTable stringTable) { // TODO: don't store type annotations in our binary metadata on Java 8, use *TypeAnnotations attributes instead for (AnnotationDescriptor annotation : type.getAnnotations()) { - proto.addExtension(JvmProtoBuf.typeAnnotation, AnnotationSerializer.INSTANCE$.serializeAnnotation(annotation, stringTable)); + proto.addExtension(JvmProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)); } } diff --git a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt index c5d7686567b..49b048795e6 100644 --- a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt +++ b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt @@ -113,7 +113,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) { // TODO: perform some kind of validation? At the moment not possible because DescriptorValidator is in compiler-tests // DescriptorValidator.validate(packageView) - val serializer = DescriptorSerializer.createTopLevel(BuiltInsSerializerExtension) + val serializer = DescriptorSerializer.createTopLevel(BuiltInsSerializerExtension(module)) val classifierDescriptors = DescriptorSerializer.sort(packageView.memberScope.getDescriptors(DescriptorKindFilter.CLASSIFIERS)) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java index e5f1117ea46..22870fd170e 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant; import org.jetbrains.kotlin.resolve.constants.CompileTimeConstantFactory; import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator; +import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage; public class JavaPropertyInitializerEvaluatorImpl implements JavaPropertyInitializerEvaluator { @Nullable @@ -40,7 +41,7 @@ public class JavaPropertyInitializerEvaluatorImpl implements JavaPropertyInitial ConstantExpressionEvaluator.isPropertyCompileTimeConstant(descriptor), false, true - )); + ), DescriptorUtilPackage.getBuiltIns(descriptor)); return factory.createCompileTimeConstant(evaluatedExpression, descriptor.getType()); } return null; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java index 51cad1c463d..a598cb915d3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -61,11 +61,9 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; public class CallExpressionResolver { private final CallResolver callResolver; - private final KotlinBuiltIns builtIns; - public CallExpressionResolver(@NotNull CallResolver callResolver, @NotNull KotlinBuiltIns builtIns) { + public CallExpressionResolver(@NotNull CallResolver callResolver) { this.callResolver = callResolver; - this.builtIns = builtIns; } private ExpressionTypingServices expressionTypingServices; @@ -372,7 +370,7 @@ public class CallExpressionResolver { CompileTimeConstant value = ConstantExpressionEvaluator.evaluate(expression, context.trace, context.expectedType); if (value instanceof IntegerValueConstant && ((IntegerValueConstant) value).isPure()) { - return ExpressionTypingUtils.createCompileTimeConstantTypeInfo(value, expression, context, builtIns); + return ExpressionTypingUtils.createCompileTimeConstantTypeInfo(value, expression, context); } JetTypeInfo typeInfo; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java index 77839c93515..907beccac42 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantChecker.java @@ -89,7 +89,7 @@ public class CompileTimeConstantChecker { } if (!noExpectedTypeOrError(expectedType)) { - JetType valueType = value.getType(builtIns); + JetType valueType = value.getType(); if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) { return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "integer", expectedType)); } @@ -106,7 +106,7 @@ public class CompileTimeConstantChecker { return reportError(FLOAT_LITERAL_OUT_OF_RANGE.on(expression)); } if (!noExpectedTypeOrError(expectedType)) { - JetType valueType = value.getType(builtIns); + JetType valueType = value.getType(); if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) { return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "floating-point", expectedType)); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt index c3c318dc2ab..05f234d0810 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt @@ -42,6 +42,8 @@ import kotlin.platform.platformStatic public class ConstantExpressionEvaluator private constructor(val trace: BindingTrace) : JetVisitor, JetType>() { + private val builtIns = KotlinBuiltIns.getInstance() + companion object { platformStatic public fun evaluate(expression: JetExpression, trace: BindingTrace, expectedType: JetType? = TypeUtils.NO_EXPECTED_TYPE): CompileTimeConstant<*>? { val evaluator = ConstantExpressionEvaluator(trace) @@ -86,7 +88,7 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT } private val stringExpressionEvaluator = object : JetVisitor() { - private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.Impl(true, false, false)) + private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.Impl(true, false, false), builtIns) fun evaluate(entry: JetStringTemplateEntry): StringValue? { return entry.accept(this, null) @@ -108,7 +110,7 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT val text = expression.getText() ?: return null val nodeElementType = expression.getNode().getElementType() - if (nodeElementType == JetNodeTypes.NULL) return NullValue + if (nodeElementType == JetNodeTypes.NULL) return NullValue(builtIns) val result: Any? = when (nodeElementType) { JetNodeTypes.INTEGER_CONSTANT -> parseLong(text) @@ -249,7 +251,7 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT val canBeUsedInAnnotation = canBeUsedInAnnotation(argumentForReceiver.expression) && canBeUsedInAnnotation(argumentForParameter.expression) val usesVariableAsConstant = usesVariableAsConstant(argumentForReceiver.expression) || usesVariableAsConstant(argumentForParameter.expression) val parameters = CompileTimeConstant.Parameters.Impl(canBeUsedInAnnotation, areArgumentsPure, usesVariableAsConstant) - val factory = CompileTimeConstantFactory(parameters) + val factory = CompileTimeConstantFactory(parameters, builtIns) return when (resultingDescriptorName) { OperatorConventions.COMPARE_TO -> createCompileTimeConstantForCompareTo(result, callExpression, factory) OperatorConventions.EQUALS -> createCompileTimeConstantForEquals(result, callExpression, factory) @@ -493,12 +495,12 @@ public class ConstantExpressionEvaluator private constructor(val trace: BindingT expectedType: JetType?, parameters: CompileTimeConstant.Parameters ): CompileTimeConstant<*>? { - return CompileTimeConstantFactory(parameters).createCompileTimeConstant(value, if (parameters.isPure) expectedType ?: TypeUtils.NO_EXPECTED_TYPE else null) + return CompileTimeConstantFactory(parameters, builtIns).createCompileTimeConstant(value, if (parameters.isPure) expectedType ?: TypeUtils.NO_EXPECTED_TYPE else null) } } public fun IntegerValueTypeConstant.createCompileTimeConstantWithType(expectedType: JetType): CompileTimeConstant<*>? - = CompileTimeConstantFactory(CompileTimeConstant.Parameters.Impl(this.canBeUsedInAnnotations(), true, false)).createCompileTimeConstant(this.getValue(expectedType)) + = CompileTimeConstantFactory(CompileTimeConstant.Parameters.Impl(this.canBeUsedInAnnotations(), true, false), KotlinBuiltIns.getInstance()).createCompileTimeConstant(this.getValue(expectedType)) private fun hasLongSuffix(text: String) = text.endsWith('l') || text.endsWith('L') @@ -594,13 +596,13 @@ private fun createCompileTimeConstantForCompareTo(result: Any?, operationReferen private fun createStringConstant(value: CompileTimeConstant<*>?): StringValue? { return when (value) { - is IntegerValueTypeConstant -> CompileTimeConstantFactory(value.parameters).createStringValue(value.getValue(TypeUtils.NO_EXPECTED_TYPE).toString()) + is IntegerValueTypeConstant -> CompileTimeConstantFactory(value.parameters, KotlinBuiltIns.getInstance()).createStringValue(value.getValue(TypeUtils.NO_EXPECTED_TYPE).toString()) is StringValue -> value is IntValue, is ByteValue, is ShortValue, is LongValue, is CharValue, is DoubleValue, is FloatValue, is BooleanValue, - is NullValue -> CompileTimeConstantFactory(value.parameters).createStringValue("${value.value}") + is NullValue -> CompileTimeConstantFactory(value.parameters, KotlinBuiltIns.getInstance()).createStringValue("${value.value}") else -> null } } 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 f7c0eb0bcda..4be38adea30 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -133,7 +133,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } assert value != null : "CompileTimeConstant should be evaluated for constant expression or an error should be recorded " + expression.getText(); - return createCompileTimeConstantTypeInfo(value, expression, context, components.builtIns); + return createCompileTimeConstantTypeInfo(value, expression, context); } @NotNull @@ -942,7 +942,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { CompileTimeConstant value = ConstantExpressionEvaluator.evaluate(expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType); if (value != null) { - return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType, components.builtIns); + return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType); } return DataFlowUtils.checkType(typeInfo.replaceType(result), @@ -1138,7 +1138,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType ); if (value != null) { - return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType, components.builtIns); + return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType); } return DataFlowUtils.checkType(result, expression, contextWithExpectedType); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java index d4ec9b5440b..0e38b188d83 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java @@ -246,10 +246,9 @@ public class ExpressionTypingUtils { public static JetTypeInfo createCompileTimeConstantTypeInfo( @NotNull CompileTimeConstant value, @NotNull JetExpression expression, - @NotNull ExpressionTypingContext context, - @NotNull KotlinBuiltIns kotlinBuiltIns + @NotNull ExpressionTypingContext context ) { - JetType expressionType = value.getType(kotlinBuiltIns); + JetType expressionType = value.getType(); if (value instanceof IntegerValueTypeConstant && context.contextDependency == INDEPENDENT) { expressionType = ((IntegerValueTypeConstant) value).getType(context.expectedType); ArgumentTypeResolver.updateNumberType(expressionType, expression, context); diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt index 72e006e402d..1091c6b491c 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.serialization import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.resolve.constants.* @@ -26,9 +27,9 @@ import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value.Typ import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.JetType -public object AnnotationSerializer { +public class AnnotationSerializer(builtIns: KotlinBuiltIns) { - private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.ThrowException) + private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.ThrowException, builtIns) public fun serializeAnnotation(annotation: AnnotationDescriptor, stringTable: StringTable): ProtoBuf.Annotation { return with(ProtoBuf.Annotation.newBuilder()) { diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt index b5b4de0c193..73f22d9608e 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerExtension.kt @@ -17,11 +17,7 @@ package org.jetbrains.kotlin.serialization.builtins import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor -import org.jetbrains.kotlin.descriptors.PropertyDescriptor -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.resolve.constants.NullValue import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter @@ -31,10 +27,13 @@ import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.SerializerExtension import org.jetbrains.kotlin.serialization.StringTable -public object BuiltInsSerializerExtension : SerializerExtension() { +public class BuiltInsSerializerExtension(module: ModuleDescriptor) : SerializerExtension() { + + private val annotationSerializer = AnnotationSerializer(module.builtIns) + override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder, stringTable: StringTable) { for (annotation in descriptor.getAnnotations()) { - proto.addExtension(BuiltInsProtoBuf.classAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable)) + proto.addExtension(BuiltInsProtoBuf.classAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)) } } @@ -58,13 +57,13 @@ public object BuiltInsSerializerExtension : SerializerExtension() { stringTable: StringTable ) { for (annotation in callable.getAnnotations()) { - proto.addExtension(BuiltInsProtoBuf.callableAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable)) + proto.addExtension(BuiltInsProtoBuf.callableAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)) } val propertyDescriptor = callable as? PropertyDescriptor ?: return val compileTimeConstant = propertyDescriptor.getCompileTimeInitializer() if (compileTimeConstant != null && compileTimeConstant !is NullValue) { - val type = compileTimeConstant.getType(propertyDescriptor.builtIns) - proto.setExtension(BuiltInsProtoBuf.compileTimeValue, AnnotationSerializer.valueProto(compileTimeConstant, type, stringTable).build()) + val valueProto = annotationSerializer.valueProto(compileTimeConstant, compileTimeConstant.type, stringTable) + proto.setExtension(BuiltInsProtoBuf.compileTimeValue, valueProto.build()) } } @@ -74,7 +73,7 @@ public object BuiltInsSerializerExtension : SerializerExtension() { stringTable: StringTable ) { for (annotation in descriptor.getAnnotations()) { - proto.addExtension(BuiltInsProtoBuf.parameterAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable)) + proto.addExtension(BuiltInsProtoBuf.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)) } } } \ No newline at end of file diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index 9aea20d079d..e1f54ca3f05 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -64,7 +64,7 @@ class LazyJavaAnnotationDescriptor( annotationClass?.getDefaultType() ?: ErrorUtils.createErrorType(fqName.asString()) } - private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.Impl(true, false, false)) + private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.Impl(true, false, false), c.module.builtIns) override fun getType(): JetType = type() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt index efa26f4f311..e856d4291d0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt @@ -46,7 +46,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl( storageManager, kotlinClassFinder, errorReporter ) { private val annotationDeserializer = AnnotationDeserializer(module) - private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.ThrowException) + private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.ThrowException, module.builtIns) override fun loadTypeAnnotation(proto: ProtoBuf.Annotation, nameResolver: NameResolver): AnnotationDescriptor = annotationDeserializer.deserializeAnnotation(proto, nameResolver) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/AnnotationValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/AnnotationValue.kt index 8dcd6304934..8ea1dc4dc19 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/AnnotationValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/AnnotationValue.kt @@ -23,7 +23,8 @@ import org.jetbrains.kotlin.types.JetType public class AnnotationValue(value: AnnotationDescriptor) : CompileTimeConstant(value, CompileTimeConstant.Parameters.Impl(true, false, false)) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = value.getType() + override val type: JetType + get() = value.getType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitAnnotationValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ArrayValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ArrayValue.kt index 46ae183fb7b..8c95657718b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ArrayValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ArrayValue.kt @@ -23,7 +23,7 @@ import java.util.* public class ArrayValue( value: List>, - private val type: JetType, + override val type: JetType, parameters: CompileTimeConstant.Parameters ) : CompileTimeConstant>>(value, parameters) { @@ -40,8 +40,6 @@ public class ArrayValue( assert(KotlinBuiltIns.isArray(type) || KotlinBuiltIns.isPrimitiveArray(type)) { "Type should be an array, but was " + type + ": " + value } } - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = type - override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitArrayValue(this, data) override fun equals(other: Any?): Boolean { diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/BooleanValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/BooleanValue.kt index d703db17024..44dd0386c75 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/BooleanValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/BooleanValue.kt @@ -22,11 +22,12 @@ import org.jetbrains.kotlin.types.JetType public class BooleanValue( value: Boolean, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : CompileTimeConstant(value, parameters) { override fun isPure(): Boolean = false - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getBooleanType() + override val type = builtIns.getBooleanType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitBooleanValue(this, data) } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ByteValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ByteValue.kt index a9d73f2b598..2b230fbc5fa 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ByteValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ByteValue.kt @@ -22,10 +22,11 @@ import org.jetbrains.kotlin.types.JetType public class ByteValue( value: Byte, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : IntegerValueConstant(value, parameters) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getByteType() + override val type = builtIns.getByteType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitByteValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CharValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CharValue.kt index f5285f8ea97..a14dd4ac4ab 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CharValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CharValue.kt @@ -22,10 +22,11 @@ import org.jetbrains.kotlin.types.JetType public class CharValue( value: Char, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : IntegerValueConstant(value, parameters) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getCharType() + override val type = builtIns.getCharType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitCharValue(this, data) 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 a9d752f6c41..cb76122cdfd 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt @@ -30,7 +30,7 @@ public abstract class CompileTimeConstant protected constructor( public open fun usesVariableAsConstant(): Boolean = parameters.usesVariableAsConstant - public abstract fun getType(kotlinBuiltIns: KotlinBuiltIns): JetType + public abstract val type: JetType public abstract fun accept(visitor: AnnotationArgumentVisitor, data: D): R diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantFactory.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantFactory.kt index 5709bc40784..2283ad75233 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantFactory.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstantFactory.kt @@ -22,28 +22,31 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.types.JetType import org.jetbrains.kotlin.types.TypeUtils -public class CompileTimeConstantFactory(private val parameters: CompileTimeConstant.Parameters) { - fun createLongValue(value: Long) = LongValue(value, parameters) +public class CompileTimeConstantFactory( + private val parameters: CompileTimeConstant.Parameters, + private val builtins: KotlinBuiltIns +) { + fun createLongValue(value: Long) = LongValue(value, parameters, builtins) - fun createIntValue(value: Int) = IntValue(value, parameters) + fun createIntValue(value: Int) = IntValue(value, parameters, builtins) fun createErrorValue(message: String) = ErrorValue.create(message) - fun createShortValue(value: Short) = ShortValue(value, parameters) + fun createShortValue(value: Short) = ShortValue(value, parameters, builtins) - fun createByteValue(value: Byte) = ByteValue(value, parameters) + fun createByteValue(value: Byte) = ByteValue(value, parameters, builtins) - fun createDoubleValue(value: Double) = DoubleValue(value, parameters) + fun createDoubleValue(value: Double) = DoubleValue(value, parameters, builtins) - fun createFloatValue(value: Float) = FloatValue(value, parameters) + fun createFloatValue(value: Float) = FloatValue(value, parameters, builtins) - fun createBooleanValue(value: Boolean) = BooleanValue(value, parameters) + fun createBooleanValue(value: Boolean) = BooleanValue(value, parameters, builtins) - fun createCharValue(value: Char) = CharValue(value, parameters) + fun createCharValue(value: Char) = CharValue(value, parameters, builtins) - fun createStringValue(value: String) = StringValue(value, parameters) + fun createStringValue(value: String) = StringValue(value, parameters, builtins) - fun createNullValue() = NullValue + fun createNullValue() = NullValue(builtins) fun createEnumValue(enumEntryClass: ClassDescriptor): EnumValue = EnumValue(enumEntryClass) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/DoubleValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/DoubleValue.kt index 111ea9acad3..1dcb99816bc 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/DoubleValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/DoubleValue.kt @@ -22,12 +22,13 @@ import org.jetbrains.kotlin.types.JetType public class DoubleValue( value: Double, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : CompileTimeConstant(value, parameters) { override fun isPure() = false - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getDoubleType() + override val type = builtIns.getDoubleType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitDoubleValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.kt index fe734397589..7c7b6197178 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.kt @@ -27,13 +27,12 @@ public class EnumValue( value: ClassDescriptor ) : CompileTimeConstant(value, CompileTimeConstant.Parameters.Impl(true, false, false)) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = getType() - - private fun getType() = value.classObjectType.sure { "Enum entry must have a class object type: " + value } + override val type: JetType + get() = value.classObjectType.sure { "Enum entry must have a class object type: " + value } override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitEnumValue(this, data) - override fun toString() = "${getType()}.${value.getName()}" + override fun toString() = "$type.${value.getName()}" override fun equals(other: Any?): Boolean { if (this === other) return true diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ErrorValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ErrorValue.kt index e73a0802c42..4a0564c6a42 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ErrorValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ErrorValue.kt @@ -31,7 +31,7 @@ public abstract class ErrorValue : CompileTimeConstant(Unit, CompileTimeCo public class ErrorValueWithMessage(public val message: String) : ErrorValue() { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = ErrorUtils.createErrorType(message) + override val type = ErrorUtils.createErrorType(message) override fun toString() = message } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/FloatValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/FloatValue.kt index c78672653ea..bb1e069e44c 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/FloatValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/FloatValue.kt @@ -22,11 +22,12 @@ import org.jetbrains.kotlin.types.JetType public class FloatValue( value: Float, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : CompileTimeConstant(value, parameters) { override fun isPure() = false - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getFloatType() + override val type = builtIns.getFloatType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitFloatValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntValue.kt index ec2bbce627b..0649089b15d 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntValue.kt @@ -22,10 +22,11 @@ import org.jetbrains.kotlin.types.JetType public class IntValue( value: Int, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : IntegerValueConstant(value, parameters) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getIntType() + override val type = builtIns.getIntType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitIntValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstant.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstant.kt index f487be511b3..054b47dc49e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstant.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/IntegerValueTypeConstant.kt @@ -32,12 +32,10 @@ public class IntegerValueTypeConstant( private val typeConstructor = IntegerValueTypeConstructor(value.toLong()) - override fun getType(kotlinBuiltIns: KotlinBuiltIns): JetType { - return JetTypeImpl( - Annotations.EMPTY, typeConstructor, false, emptyList() - , ErrorUtils.createErrorScope("Scope for number value type (" + typeConstructor.toString() + ")", true) - ) - } + override val type = JetTypeImpl( + Annotations.EMPTY, typeConstructor, false, emptyList() + , ErrorUtils.createErrorScope("Scope for number value type (" + typeConstructor.toString() + ")", true) + ) deprecated("") override val value: Number diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/KClassValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/KClassValue.kt index 9a6a867198e..a3eedd4e0b8 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/KClassValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/KClassValue.kt @@ -20,9 +20,8 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor import org.jetbrains.kotlin.types.JetType -public class KClassValue(private val type: JetType) : +public class KClassValue(override val type: JetType) : CompileTimeConstant(type, CompileTimeConstant.Parameters.Impl(true, false, false)) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = type override val value: JetType get() = type.getArguments().single().getType() diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/LongValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/LongValue.kt index fe443987362..24811e33a6e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/LongValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/LongValue.kt @@ -22,10 +22,11 @@ import org.jetbrains.kotlin.types.JetType public class LongValue( value: Long, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : IntegerValueConstant(value, parameters) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getLongType() + override val type = builtIns.getLongType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitLongValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/NullValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/NullValue.kt index 5554fc8167a..7676cdcdca7 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/NullValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/NullValue.kt @@ -20,9 +20,11 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor import org.jetbrains.kotlin.types.JetType -public object NullValue : CompileTimeConstant(null, CompileTimeConstant.Parameters.Impl(false, false, false)) { +public class NullValue( + builtIns: KotlinBuiltIns +) : CompileTimeConstant(null, CompileTimeConstant.Parameters.Impl(false, false, false)) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getNullableNothingType() + override val type = builtIns.getNullableNothingType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitNullValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ShortValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ShortValue.kt index 917fcb77f1f..45b6c88a745 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ShortValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ShortValue.kt @@ -22,10 +22,11 @@ import org.jetbrains.kotlin.types.JetType public class ShortValue( value: Short, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : IntegerValueConstant(value, parameters) { - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getShortType() + override val type = builtIns.getShortType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitShortValue(this, data) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/StringValue.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/StringValue.kt index 26c9b2c5286..530e310f9d1 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/StringValue.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/StringValue.kt @@ -22,11 +22,12 @@ import org.jetbrains.kotlin.types.JetType public class StringValue( value: String, - parameters: CompileTimeConstant.Parameters + parameters: CompileTimeConstant.Parameters, + builtIns: KotlinBuiltIns ) : CompileTimeConstant(value, parameters) { override fun isPure() = false - override fun getType(kotlinBuiltIns: KotlinBuiltIns) = kotlinBuiltIns.getStringType() + override val type = builtIns.getStringType() override fun accept(visitor: AnnotationArgumentVisitor, data: D) = visitor.visitStringValue(this, data) diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt index 69f858a0ffe..3773495ecc1 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt @@ -39,7 +39,7 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) { private val builtIns: KotlinBuiltIns get() = module.builtIns - private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.ThrowException) + private val factory = CompileTimeConstantFactory(CompileTimeConstant.Parameters.ThrowException, builtIns) public fun deserializeAnnotation(proto: Annotation, nameResolver: NameResolver): AnnotationDescriptor { val annotationClass = resolveClass(nameResolver.getClassId(proto.getId())) @@ -121,7 +121,7 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) { else -> error("Unsupported annotation argument type: ${value.getType()} (expected $expectedType)") } - if (result.getType(builtIns) isSubtypeOf expectedType) { + if (result.type isSubtypeOf expectedType) { return result } else { diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt index 90d5eec26a9..e680b560895 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt +++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.serialization.js +import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor @@ -29,9 +30,12 @@ import org.jetbrains.kotlin.serialization.StringTable import org.jetbrains.kotlin.types.JetType public object KotlinJavascriptSerializerExtension : SerializerExtension() { + + private val annotationSerializer = AnnotationSerializer(KotlinBuiltIns.getInstance()) + override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder, stringTable: StringTable) { for (annotation in descriptor.getAnnotations()) { - proto.addExtension(JsProtoBuf.classAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable)) + proto.addExtension(JsProtoBuf.classAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)) } } @@ -41,13 +45,13 @@ public object KotlinJavascriptSerializerExtension : SerializerExtension() { stringTable: StringTable ) { for (annotation in callable.getAnnotations()) { - proto.addExtension(JsProtoBuf.callableAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable)) + proto.addExtension(JsProtoBuf.callableAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)) } val propertyDescriptor = callable as? PropertyDescriptor ?: return val compileTimeConstant = propertyDescriptor.getCompileTimeInitializer() if (compileTimeConstant != null && compileTimeConstant !is NullValue) { - val type = compileTimeConstant.getType(propertyDescriptor.builtIns) - proto.setExtension(JsProtoBuf.compileTimeValue, AnnotationSerializer.valueProto(compileTimeConstant, type, stringTable).build()) + val type = compileTimeConstant.type + proto.setExtension(JsProtoBuf.compileTimeValue, annotationSerializer.valueProto(compileTimeConstant, type, stringTable).build()) } } @@ -57,13 +61,13 @@ public object KotlinJavascriptSerializerExtension : SerializerExtension() { stringTable: StringTable ) { for (annotation in descriptor.getAnnotations()) { - proto.addExtension(JsProtoBuf.parameterAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable)) + proto.addExtension(JsProtoBuf.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)) } } override fun serializeType(type: JetType, proto: ProtoBuf.Type.Builder, stringTable: StringTable) { for (annotation in type.getAnnotations()) { - proto.addExtension(JsProtoBuf.typeAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable)) + proto.addExtension(JsProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation, stringTable)) } } }