From 47f78c424d32a78da12633fc33a73601f757a9a2 Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Wed, 25 Dec 2019 02:50:43 +0300 Subject: [PATCH] Commonize KType API Move KTypeProjection, KVariance, KClassifier, KTypeParameter to stdlib-common. #KT-29748 Fixed #KT-32855 Fixed --- .../jvm/src/kotlin/reflect/KClassifier.kt | 26 ----- .../stdlib/jvm/src/kotlin/reflect/KType.kt | 60 +--------- .../stdlib/src/kotlin/reflect/KClassifier.kt | 15 +++ libraries/stdlib/src/kotlin/reflect/KType.kt | 105 ++++++++++++++++++ .../src/kotlin/reflect/KTypeParameter.kt | 2 +- .../{jvm => }/src/kotlin/reflect/KVariance.kt | 17 +-- 6 files changed, 128 insertions(+), 97 deletions(-) delete mode 100644 libraries/stdlib/jvm/src/kotlin/reflect/KClassifier.kt create mode 100644 libraries/stdlib/src/kotlin/reflect/KClassifier.kt create mode 100644 libraries/stdlib/src/kotlin/reflect/KType.kt rename libraries/stdlib/{jvm => }/src/kotlin/reflect/KTypeParameter.kt (99%) rename libraries/stdlib/{jvm => }/src/kotlin/reflect/KVariance.kt (58%) diff --git a/libraries/stdlib/jvm/src/kotlin/reflect/KClassifier.kt b/libraries/stdlib/jvm/src/kotlin/reflect/KClassifier.kt deleted file mode 100644 index 3c804e9cfa6..00000000000 --- a/libraries/stdlib/jvm/src/kotlin/reflect/KClassifier.kt +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2010-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package kotlin.reflect - -/** - * A classifier is either a class or a type parameter. - * - * @see [KClass] - * @see [KTypeParameter] - */ -@SinceKotlin("1.1") -public interface KClassifier diff --git a/libraries/stdlib/jvm/src/kotlin/reflect/KType.kt b/libraries/stdlib/jvm/src/kotlin/reflect/KType.kt index dc3263244f3..742c89e5cf2 100644 --- a/libraries/stdlib/jvm/src/kotlin/reflect/KType.kt +++ b/libraries/stdlib/jvm/src/kotlin/reflect/KType.kt @@ -9,7 +9,7 @@ package kotlin.reflect * Represents a type. Type is usually either a class with optional type arguments, * or a type parameter of some declaration, plus nullability. */ -public interface KType : KAnnotatedElement { +public actual interface KType : KAnnotatedElement { /** * The declaration of the classifier used in this type. * For example, in the type `List` the classifier would be the [KClass] instance for [List]. @@ -17,7 +17,7 @@ public interface KType : KAnnotatedElement { * Returns `null` if this type is not denotable in Kotlin, for example if it is an intersection type. */ @SinceKotlin("1.1") - public val classifier: KClassifier? + public actual val classifier: KClassifier? /** * Type arguments passed for the parameters of the classifier in this type. @@ -28,7 +28,7 @@ public interface KType : KAnnotatedElement { * For example, in the type `Outer.Inner` the returned list is `[C, D, A, B]`. */ @SinceKotlin("1.1") - public val arguments: List + public actual val arguments: List /** * `true` if this type was marked nullable in the source code. @@ -47,58 +47,6 @@ public interface KType : KAnnotatedElement { * } * ``` */ - public val isMarkedNullable: Boolean + public actual val isMarkedNullable: Boolean } -/** - * Represents a type projection. Type projection is usually the argument to another type in a type usage. - * For example, in the type `Array`, `out Number` is the covariant projection of the type represented by the class `Number`. - * - * Type projection is either the star projection, or an entity consisting of a specific type plus optional variance. - * - * See the [Kotlin language documentation](https://kotlinlang.org/docs/reference/generics.html#type-projections) - * for more information. - */ -@SinceKotlin("1.1") -public data class KTypeProjection constructor( - /** - * The use-site variance specified in the projection, or `null` if this is a star projection. - */ - public val variance: KVariance?, - /** - * The type specified in the projection, or `null` if this is a star projection. - */ - public val type: KType? -) { - public companion object { - /** - * Star projection, denoted by the `*` character. - * For example, in the type `KClass<*>`, `*` is the star projection. - * See the [Kotlin language documentation](https://kotlinlang.org/docs/reference/generics.html#star-projections) - * for more information. - */ - public val STAR: KTypeProjection = KTypeProjection(null, null) - - /** - * Creates an invariant projection of a given type. Invariant projection is just the type itself, - * without any use-site variance modifiers applied to it. - * For example, in the type `Set`, `String` is an invariant projection of the type represented by the class `String`. - */ - public fun invariant(type: KType): KTypeProjection = - KTypeProjection(KVariance.INVARIANT, type) - - /** - * Creates a contravariant projection of a given type, denoted by the `in` modifier applied to a type. - * For example, in the type `MutableList`, `in Number` is a contravariant projection of the type of class `Number`. - */ - public fun contravariant(type: KType): KTypeProjection = - KTypeProjection(KVariance.IN, type) - - /** - * Creates a covariant projection of a given type, denoted by the `out` modifier applied to a type. - * For example, in the type `Array`, `out Number` is a covariant projection of the type of class `Number`. - */ - public fun covariant(type: KType): KTypeProjection = - KTypeProjection(KVariance.OUT, type) - } -} diff --git a/libraries/stdlib/src/kotlin/reflect/KClassifier.kt b/libraries/stdlib/src/kotlin/reflect/KClassifier.kt new file mode 100644 index 00000000000..f556bf48eb2 --- /dev/null +++ b/libraries/stdlib/src/kotlin/reflect/KClassifier.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package kotlin.reflect + +/** + * A classifier is either a class or a type parameter. + * + * @see [KClass] + * @see [KTypeParameter] + */ +@SinceKotlin("1.1") +public interface KClassifier \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/reflect/KType.kt b/libraries/stdlib/src/kotlin/reflect/KType.kt new file mode 100644 index 00000000000..08ccf4957ec --- /dev/null +++ b/libraries/stdlib/src/kotlin/reflect/KType.kt @@ -0,0 +1,105 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package kotlin.reflect + +/** + * Represents a type. Type is usually either a class with optional type arguments, + * or a type parameter of some declaration, plus nullability. + */ +public expect interface KType { + /** + * The declaration of the classifier used in this type. + * For example, in the type `List` the classifier would be the [KClass] instance for [List]. + * + * Returns `null` if this type is not denotable in Kotlin, for example if it is an intersection type. + */ + @SinceKotlin("1.1") + public val classifier: KClassifier? + + /** + * Type arguments passed for the parameters of the classifier in this type. + * For example, in the type `Array` the only type argument is `out Number`. + * + * In case this type is based on an inner class, the returned list contains the type arguments provided for the innermost class first, + * then its outer class, and so on. + * For example, in the type `Outer.Inner` the returned list is `[C, D, A, B]`. + */ + @SinceKotlin("1.1") + public val arguments: List + + /** + * `true` if this type was marked nullable in the source code. + * + * For Kotlin types, it means that `null` value is allowed to be represented by this type. + * In practice it means that the type was declared with a question mark at the end. + * For non-Kotlin types, it means the type or the symbol which was declared with this type + * is annotated with a runtime-retained nullability annotation such as [javax.annotation.Nullable]. + * + * Note that even if [isMarkedNullable] is false, values of the type can still be `null`. + * This may happen if it is a type of the type parameter with a nullable upper bound: + * + * ``` + * fun foo(t: T) { + * // isMarkedNullable == false for t's type, but t can be null here when T = "Any?" + * } + * ``` + */ + public val isMarkedNullable: Boolean +} + + +/** + * Represents a type projection. Type projection is usually the argument to another type in a type usage. + * For example, in the type `Array`, `out Number` is the covariant projection of the type represented by the class `Number`. + * + * Type projection is either the star projection, or an entity consisting of a specific type plus optional variance. + * + * See the [Kotlin language documentation](https://kotlinlang.org/docs/reference/generics.html#type-projections) + * for more information. + */ +@SinceKotlin("1.1") +public data class KTypeProjection constructor( + /** + * The use-site variance specified in the projection, or `null` if this is a star projection. + */ + public val variance: KVariance?, + /** + * The type specified in the projection, or `null` if this is a star projection. + */ + public val type: KType? +) { + public companion object { + /** + * Star projection, denoted by the `*` character. + * For example, in the type `KClass<*>`, `*` is the star projection. + * See the [Kotlin language documentation](https://kotlinlang.org/docs/reference/generics.html#star-projections) + * for more information. + */ + public val STAR: KTypeProjection = KTypeProjection(null, null) + + /** + * Creates an invariant projection of a given type. Invariant projection is just the type itself, + * without any use-site variance modifiers applied to it. + * For example, in the type `Set`, `String` is an invariant projection of the type represented by the class `String`. + */ + public fun invariant(type: KType): KTypeProjection = + KTypeProjection(KVariance.INVARIANT, type) + + /** + * Creates a contravariant projection of a given type, denoted by the `in` modifier applied to a type. + * For example, in the type `MutableList`, `in Number` is a contravariant projection of the type of class `Number`. + */ + public fun contravariant(type: KType): KTypeProjection = + KTypeProjection(KVariance.IN, type) + + /** + * Creates a covariant projection of a given type, denoted by the `out` modifier applied to a type. + * For example, in the type `Array`, `out Number` is a covariant projection of the type of class `Number`. + */ + public fun covariant(type: KType): KTypeProjection = + KTypeProjection(KVariance.OUT, type) + } +} diff --git a/libraries/stdlib/jvm/src/kotlin/reflect/KTypeParameter.kt b/libraries/stdlib/src/kotlin/reflect/KTypeParameter.kt similarity index 99% rename from libraries/stdlib/jvm/src/kotlin/reflect/KTypeParameter.kt rename to libraries/stdlib/src/kotlin/reflect/KTypeParameter.kt index 5351ffc7100..30451663a62 100644 --- a/libraries/stdlib/jvm/src/kotlin/reflect/KTypeParameter.kt +++ b/libraries/stdlib/src/kotlin/reflect/KTypeParameter.kt @@ -37,4 +37,4 @@ public interface KTypeParameter : KClassifier { * for more information. */ public val isReified: Boolean -} +} \ No newline at end of file diff --git a/libraries/stdlib/jvm/src/kotlin/reflect/KVariance.kt b/libraries/stdlib/src/kotlin/reflect/KVariance.kt similarity index 58% rename from libraries/stdlib/jvm/src/kotlin/reflect/KVariance.kt rename to libraries/stdlib/src/kotlin/reflect/KVariance.kt index 9a237cbbb9b..17d05971f2e 100644 --- a/libraries/stdlib/jvm/src/kotlin/reflect/KVariance.kt +++ b/libraries/stdlib/src/kotlin/reflect/KVariance.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package kotlin.reflect @@ -42,4 +31,4 @@ enum class KVariance { * The affected type parameter or type is *covariant*. Denoted by the `out` modifier in the source code. */ OUT, -} +} \ No newline at end of file