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

Remove unneeded members of ConstantValueFactory

Browse Source
This commit is contained in:
Alexander Udalov
2017-12-29 17:03:19 +01:00
parent 82574cb570
commit b3eeb2f735
8 changed files with 69 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt
+2 -2
View File
@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.constants.ArrayValue
import org.jetbrains.kotlin.resolve.constants.ConstantValue
import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
import org.jetbrains.kotlin.resolve.constants.EnumValue
import org.jetbrains.kotlin.resolve.constants.StringValue
import org.jetbrains.kotlin.storage.getValue
import org.jetbrains.kotlin.types.ErrorUtils
import org.jetbrains.kotlin.types.SimpleType
@@ -114,7 +114,7 @@ class JavaDeprecatedAnnotationDescriptor(
c: LazyJavaResolverContext
): JavaAnnotationDescriptor(c, annotation, KotlinBuiltIns.FQ_NAMES.deprecated) {
override val allValueArguments: Map<Name, ConstantValue<*>> by c.storageManager.createLazyValue {
mapOf(JavaAnnotationMapper.DEPRECATED_ANNOTATION_MESSAGE to ConstantValueFactory.createStringValue("Deprecated in Java"))
mapOf(JavaAnnotationMapper.DEPRECATED_ANNOTATION_MESSAGE to StringValue("Deprecated in Java"))
}
}
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
+4 -6
View File
@@ -31,9 +31,7 @@ import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
import org.jetbrains.kotlin.renderer.DescriptorRenderer
import org.jetbrains.kotlin.resolve.constants.ConstantValue
import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
import org.jetbrains.kotlin.resolve.constants.EnumValue
import org.jetbrains.kotlin.resolve.constants.*
import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
import org.jetbrains.kotlin.resolve.descriptorUtil.resolveTopLevelClass
import org.jetbrains.kotlin.storage.getValue
@@ -76,7 +74,7 @@ class LazyJavaAnnotationDescriptor(
}
private fun resolveFromAnnotation(javaAnnotation: JavaAnnotation): ConstantValue<*> {
return ConstantValueFactory.createAnnotationValue(LazyJavaAnnotationDescriptor(c, javaAnnotation))
return AnnotationValue(LazyJavaAnnotationDescriptor(c, javaAnnotation))
}
private fun resolveFromArray(argumentName: Name, elements: List<JavaAnnotationArgument>): ConstantValue<*>? {
@@ -91,7 +89,7 @@ class LazyJavaAnnotationDescriptor(
)
val values = elements.map {
argument -> resolveAnnotationArgument(argument) ?: ConstantValueFactory.createNullValue()
argument -> resolveAnnotationArgument(argument) ?: NullValue()
}
return ConstantValueFactory.createArrayValue(values, arrayType)
@@ -116,7 +114,7 @@ class LazyJavaAnnotationDescriptor(
val javaClassObjectType = KotlinTypeFactory.simpleNotNullType(Annotations.EMPTY, jlClass, arguments)
return ConstantValueFactory.createKClassValue(javaClassObjectType)
return KClassValue(javaClassObjectType)
}
override fun toString(): String {
core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt
+3 -6
View File
@@ -25,10 +25,7 @@ import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils
import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.constants.AnnotationValue
import org.jetbrains.kotlin.resolve.constants.ConstantValue
import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
import org.jetbrains.kotlin.resolve.constants.EnumValue
import org.jetbrains.kotlin.resolve.constants.*
import org.jetbrains.kotlin.serialization.ProtoBuf
import org.jetbrains.kotlin.serialization.deserialization.AnnotationDeserializer
import org.jetbrains.kotlin.serialization.deserialization.NameResolver
@@ -137,8 +134,8 @@ class BinaryClassAnnotationAndConstantLoaderImpl(
}
private fun createConstant(name: Name?, value: Any?): ConstantValue<*> {
return ConstantValueFactory.createConstantValue(value) ?:
ConstantValueFactory.createErrorValue("Unsupported annotation argument: $name")
return ConstantValueFactory.createConstantValue(value)
?: ErrorValue.create("Unsupported annotation argument: $name")
}
}
}
core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt
+1 -2
View File
@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.descriptors.annotations.BuiltInAnnotationDescriptor
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqNameUnsafe
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
import org.jetbrains.kotlin.resolve.constants.StringValue
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
import org.jetbrains.kotlin.types.*
@@ -169,7 +168,7 @@ fun getFunctionTypeArgumentProjections(
val parameterNameAnnotation = BuiltInAnnotationDescriptor(
builtIns,
KotlinBuiltIns.FQ_NAMES.parameterName,
mapOf(Name.identifier("name") to ConstantValueFactory.createStringValue(name.asString()))
mapOf(Name.identifier("name") to StringValue(name.asString()))
)
type.replaceAnnotations(AnnotationsImpl(type.annotations + parameterNameAnnotation))
}
core/descriptors/src/org/jetbrains/kotlin/resolve/constants/CompileTimeConstant.kt
+4 -4
View File
@@ -88,10 +88,10 @@ class IntegerValueTypeConstant(
override fun toConstantValue(expectedType: KotlinType): ConstantValue<Number> {
val type = getType(expectedType)
return when {
KotlinBuiltIns.isInt(type) -> ConstantValueFactory.createIntValue(value.toInt())
KotlinBuiltIns.isByte(type) -> ConstantValueFactory.createByteValue(value.toByte())
KotlinBuiltIns.isShort(type) -> ConstantValueFactory.createShortValue(value.toShort())
else -> ConstantValueFactory.createLongValue(value.toLong())
KotlinBuiltIns.isInt(type) -> IntValue(value.toInt())
KotlinBuiltIns.isByte(type) -> ByteValue(value.toByte())
KotlinBuiltIns.isShort(type) -> ShortValue(value.toShort())
else -> LongValue(value.toLong())
}
}
core/descriptors/src/org/jetbrains/kotlin/resolve/constants/ConstantValueFactory.kt
+28 -60
View File
@@ -18,72 +18,40 @@ package org.jetbrains.kotlin.resolve.constants
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.builtins.PrimitiveType
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.TypeUtils
object ConstantValueFactory {
fun createLongValue(value: Long) = LongValue(value)
fun createIntValue(value: Int) = IntValue(value)
fun createErrorValue(message: String) = ErrorValue.create(message)
fun createShortValue(value: Short) = ShortValue(value)
fun createByteValue(value: Byte) = ByteValue(value)
fun createDoubleValue(value: Double) = DoubleValue(value)
fun createFloatValue(value: Float) = FloatValue(value)
fun createBooleanValue(value: Boolean) = BooleanValue(value)
fun createCharValue(value: Char) = CharValue(value)
fun createStringValue(value: String) = StringValue(value)
fun createNullValue() = NullValue()
fun createArrayValue(value: List<ConstantValue<*>>, type: KotlinType) = createArrayValue(value) { type }
fun createAnnotationValue(value: AnnotationDescriptor) = AnnotationValue(value)
fun createKClassValue(type: KotlinType) = KClassValue(type)
fun createArrayValue(value: List<ConstantValue<*>>, type: KotlinType) = ArrayValue(value) { type }
fun createConstantValue(value: Any?): ConstantValue<*>? {
return when (value) {
is Byte -> createByteValue(value)
is Short -> createShortValue(value)
is Int -> createIntValue(value)
is Long -> createLongValue(value)
is Char -> createCharValue(value)
is Float -> createFloatValue(value)
is Double -> createDoubleValue(value)
is Boolean -> createBooleanValue(value)
is String -> createStringValue(value)
is ByteArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.BYTE.arrayType())
is ShortArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.SHORT.arrayType())
is IntArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.INT.arrayType())
is LongArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.LONG.arrayType())
is CharArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.CHAR.arrayType())
is FloatArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.FLOAT.arrayType())
is DoubleArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.DOUBLE.arrayType())
is BooleanArray -> createArrayValue(value.toList().arrayToList(), PrimitiveType.BOOLEAN.arrayType())
null -> createNullValue()
is Byte -> ByteValue(value)
is Short -> ShortValue(value)
is Int -> IntValue(value)
is Long -> LongValue(value)
is Char -> CharValue(value)
is Float -> FloatValue(value)
is Double -> DoubleValue(value)
is Boolean -> BooleanValue(value)
is String -> StringValue(value)
is ByteArray -> createArrayValue(value.toList(), PrimitiveType.BYTE)
is ShortArray -> createArrayValue(value.toList(), PrimitiveType.SHORT)
is IntArray -> createArrayValue(value.toList(), PrimitiveType.INT)
is LongArray -> createArrayValue(value.toList(), PrimitiveType.LONG)
is CharArray -> createArrayValue(value.toList(), PrimitiveType.CHAR)
is FloatArray -> createArrayValue(value.toList(), PrimitiveType.FLOAT)
is DoubleArray -> createArrayValue(value.toList(), PrimitiveType.DOUBLE)
is BooleanArray -> createArrayValue(value.toList(), PrimitiveType.BOOLEAN)
null -> NullValue()
else -> null
}
}
private fun createArrayValue(value: List<ConstantValue<*>>, computeType: (ModuleDescriptor) -> KotlinType): ArrayValue =
ArrayValue(value, computeType)
private fun List<*>.arrayToList(): List<ConstantValue<*>> =
this.toList().mapNotNull { createConstantValue(it) }
private fun PrimitiveType.arrayType(): (ModuleDescriptor) -> KotlinType =
{ module -> module.builtIns.getPrimitiveArrayKotlinType(this) }
private fun createArrayValue(value: List<*>, componentType: PrimitiveType): ArrayValue =
ArrayValue(value.toList().mapNotNull(this::createConstantValue)) { module ->
module.builtIns.getPrimitiveArrayKotlinType(componentType)
}
fun createIntegerConstantValue(
value: Long,
@@ -91,11 +59,11 @@ object ConstantValueFactory {
): ConstantValue<*>? {
val notNullExpected = TypeUtils.makeNotNullable(expectedType)
return when {
KotlinBuiltIns.isLong(notNullExpected) -> createLongValue(value)
KotlinBuiltIns.isInt(notNullExpected) && value == value.toInt().toLong() -> createIntValue(value.toInt())
KotlinBuiltIns.isShort(notNullExpected) && value == value.toShort().toLong() -> createShortValue(value.toShort())
KotlinBuiltIns.isByte(notNullExpected) && value == value.toByte().toLong() -> createByteValue(value.toByte())
KotlinBuiltIns.isChar(notNullExpected) -> createIntValue(value.toInt())
KotlinBuiltIns.isLong(notNullExpected) -> LongValue(value)
KotlinBuiltIns.isInt(notNullExpected) && value == value.toInt().toLong() -> IntValue(value.toInt())
KotlinBuiltIns.isShort(notNullExpected) && value == value.toShort().toLong() -> ShortValue(value.toShort())
KotlinBuiltIns.isByte(notNullExpected) && value == value.toByte().toLong() -> ByteValue(value.toByte())
KotlinBuiltIns.isChar(notNullExpected) -> IntValue(value.toInt())
else -> null
}
}
core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt
+12 -15
View File
@@ -24,10 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.DescriptorUtils
import org.jetbrains.kotlin.resolve.constants.AnnotationValue
import org.jetbrains.kotlin.resolve.constants.ConstantValue
import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
import org.jetbrains.kotlin.resolve.constants.EnumValue
import org.jetbrains.kotlin.resolve.constants.*
import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation
import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument
import org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.Argument.Value
@@ -70,16 +67,16 @@ class AnnotationDeserializer(private val module: ModuleDescriptor, private val n
nameResolver: NameResolver
): ConstantValue<*> {
val result: ConstantValue<*> = when (value.type) {
Type.BYTE -> ConstantValueFactory.createByteValue(value.intValue.toByte())
Type.CHAR -> ConstantValueFactory.createCharValue(value.intValue.toChar())
Type.SHORT -> ConstantValueFactory.createShortValue(value.intValue.toShort())
Type.INT -> ConstantValueFactory.createIntValue(value.intValue.toInt())
Type.LONG -> ConstantValueFactory.createLongValue(value.intValue)
Type.FLOAT -> ConstantValueFactory.createFloatValue(value.floatValue)
Type.DOUBLE -> ConstantValueFactory.createDoubleValue(value.doubleValue)
Type.BOOLEAN -> ConstantValueFactory.createBooleanValue(value.intValue != 0L)
Type.BYTE -> ByteValue(value.intValue.toByte())
Type.CHAR -> CharValue(value.intValue.toChar())
Type.SHORT -> ShortValue(value.intValue.toShort())
Type.INT -> IntValue(value.intValue.toInt())
Type.LONG -> LongValue(value.intValue)
Type.FLOAT -> FloatValue(value.floatValue)
Type.DOUBLE -> DoubleValue(value.doubleValue)
Type.BOOLEAN -> BooleanValue(value.intValue != 0L)
Type.STRING -> {
ConstantValueFactory.createStringValue(nameResolver.getString(value.stringValue))
StringValue(nameResolver.getString(value.stringValue))
}
Type.CLASS -> {
resolveClassLiteralValue(nameResolver.getClassId(value.classId))
@@ -124,7 +121,7 @@ class AnnotationDeserializer(private val module: ModuleDescriptor, private val n
}
else {
// This means that an annotation class has been changed incompatibly without recompiling clients
ConstantValueFactory.createErrorValue("Unexpected argument value")
ErrorValue.create("Unexpected argument value")
}
}
@@ -134,7 +131,7 @@ class AnnotationDeserializer(private val module: ModuleDescriptor, private val n
val starProjectedType = resolveClass(classId).defaultType.replaceArgumentsWithStarProjections()
val kClass = resolveClass(ClassId.topLevel(KotlinBuiltIns.FQ_NAMES.kClass.toSafe()))
val type = KotlinTypeFactory.simpleNotNullType(Annotations.EMPTY, kClass, listOf(TypeProjectionImpl(starProjectedType)))
return ConstantValueFactory.createKClassValue(type)
return KClassValue(type)
}
private fun resolveArrayElementType(value: Value, nameResolver: NameResolver): SimpleType =