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

[IR] Unite inline class and multi-field value class representation

Browse Source 
#KT-1179
This commit is contained in:
Evgeniy.Zhelenskiy
2022-03-10 00:02:35 +03:00
committed by teamcity
parent 282ab398c6
commit 28bf83ceac
69 changed files with 2464 additions and 3598 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java
+2 -2
View File
@@ -59,6 +59,7 @@ import static org.jetbrains.kotlin.codegen.DescriptorAsmUtil.*;
import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isConst;
import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLOSURE;
import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION;
import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getInlineClassRepresentation;
import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
import static org.jetbrains.org.objectweb.asm.Opcodes.*;
@@ -382,8 +383,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
}
if (InlineClassesCodegenUtilKt.isInlineClassWithUnderlyingTypeAnyOrAnyN(parameterType) && functionReferenceCall == null) {
ClassDescriptor descriptor = TypeUtils.getClassDescriptor(parameterType);
InlineClassRepresentation<SimpleType> representation =
descriptor != null ? descriptor.getInlineClassRepresentation() : null;
InlineClassRepresentation<SimpleType> representation = getInlineClassRepresentation(descriptor);
assert representation != null : "Not an inline class type: " + parameterType;
parameterType = representation.getUnderlyingType();
}
compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java
+2 -2
View File
@@ -117,6 +117,7 @@ import static org.jetbrains.kotlin.resolve.BindingContext.*;
import static org.jetbrains.kotlin.resolve.BindingContextUtils.getDelegationConstructorCall;
import static org.jetbrains.kotlin.resolve.BindingContextUtils.isBoxedLocalCapturedInClosure;
import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getInlineClassRepresentation;
import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
import static org.jetbrains.kotlin.types.RangeUtilKt.isPrimitiveNumberClassDescriptor;
import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionExpression;
@@ -1998,8 +1999,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
!CoroutineCodegenUtilKt.isInvokeSuspendOfLambda(context.getFunctionDescriptor())
) {
ClassDescriptor inlineClass = (ClassDescriptor) inlineClassType.getConstructor().getDeclarationDescriptor();
InlineClassRepresentation<SimpleType> representation =
inlineClass != null ? inlineClass.getInlineClassRepresentation() : null;
InlineClassRepresentation<SimpleType> representation = getInlineClassRepresentation(inlineClass);
assert representation != null : "Not an inline class: " + inlineClassType;
KotlinType underlyingType = representation.getUnderlyingType();
return StackValue.underlyingValueOfInlineClass(typeMapper.mapType(underlyingType), underlyingType, localOrCaptured);
compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java
+2 -1
View File
@@ -79,6 +79,7 @@ import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DEL
import static org.jetbrains.kotlin.descriptors.ModalityUtilsKt.isOverridable;
import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.getSourceFromDescriptor;
import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getInlineClassRepresentation;
import static org.jetbrains.kotlin.resolve.inline.InlineOnlyKt.isInlineOnlyPrivateInBytecode;
import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
import static org.jetbrains.kotlin.resolve.jvm.InlineClassManglingRulesKt.shouldHideConstructorDueToInlineClassTypeValueParameters;
@@ -378,7 +379,7 @@ public class FunctionCodegen {
Type fieldOwnerType = typeMapper.mapClass(inlineClass);
Method erasedMethodImpl = typeMapper.mapAsmMethod(functionDescriptor.getOriginal(), OwnerKind.ERASED_INLINE_CLASS);
InlineClassRepresentation<SimpleType> representation = inlineClass.getInlineClassRepresentation();
InlineClassRepresentation<SimpleType> representation = getInlineClassRepresentation(inlineClass);
assert representation != null : "Not an inline class: " + inlineClass;
generateDelegateToStaticErasedVersion(
compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java
+2 -1
View File
@@ -82,6 +82,7 @@ import static org.jetbrains.kotlin.resolve.BindingContext.INDEXED_LVALUE_SET;
import static org.jetbrains.kotlin.resolve.BindingContextUtils.getNotNull;
import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getInlineClassRepresentation;
import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
import static org.jetbrains.kotlin.types.Variance.INVARIANT;
@@ -276,7 +277,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
@Override
protected void generateUnboxMethodForInlineClass() {
if (!(myClass instanceof KtClass)) return;
InlineClassRepresentation<SimpleType> inlineClassRepresentation = descriptor.getInlineClassRepresentation();
InlineClassRepresentation<SimpleType> inlineClassRepresentation = getInlineClassRepresentation(descriptor);
if (inlineClassRepresentation == null) return;
Type ownerType = typeMapper.mapClass(descriptor);
compiler/backend/src/org/jetbrains/kotlin/codegen/inlineClassesCodegenUtil.kt
+1
View File
@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.resolve.descriptorUtil.classId
import org.jetbrains.kotlin.resolve.descriptorUtil.inlineClassRepresentation
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor
import org.jetbrains.kotlin.types.KotlinType
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt
+4 -15
View File
@@ -643,21 +643,10 @@ fun Fir2IrComponents.createTemporaryVariableForSafeCallConstruction(
): Pair<IrVariable, IrValueSymbol> =
createTemporaryVariable(receiverExpression, conversionScope, "safe_receiver")
// TODO: implement inlineClassRepresentation in FirRegularClass instead.
fun Fir2IrComponents.computeInlineClassRepresentation(klass: FirRegularClass): InlineClassRepresentation<IrSimpleType>? {
if (!(klass.isInline && klass.primaryConstructorIfAny(session)?.valueParameterSymbols?.size == 1)) return null
val parameter = klass.getInlineClassUnderlyingParameter(session) ?: error("Inline class has no underlying parameter: ${klass.render()}")
val underlyingType = parameter.returnTypeRef.toIrType(typeConverter)
return InlineClassRepresentation(
parameter.name,
underlyingType as? IrSimpleType ?: error("Inline class underlying type is not a simple type: ${klass.render()}")
)
}
// TODO: implement multiFieldValueClassRepresentation in FirRegularClass instead.
fun Fir2IrComponents.computeMultiFieldValueClassRepresentation(klass: FirRegularClass): MultiFieldValueClassRepresentation<IrSimpleType>? {
val parameters = klass.getMultiFieldValueClassUnderlyingParameters(session) ?: return null
return MultiFieldValueClassRepresentation(parameters.map {
// TODO: implement valueClassRepresentation in FirRegularClass instead. zhelenskiy
fun Fir2IrComponents.computeValueClassRepresentation(klass: FirRegularClass): ValueClassRepresentation<IrSimpleType>? {
val parameters = klass.getValueClassUnderlyingParameters(session) ?: return null
return createValueClassRepresentation(IrTypeSystemContextImpl(irBuiltIns), parameters.map {
val type = it.returnTypeRef.toIrType(typeConverter).safeAs<IrSimpleType>()
?: error("Value class underlying type is not a simple type: ${klass.render()}")
it.name to type
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt
+3 -3
View File
@@ -133,9 +133,9 @@ class Fir2IrClassifierStorage(
superTypes = klass.superTypeRefs.map { superTypeRef -> superTypeRef.toIrType() }
}
private fun IrClass.declareInlineClassRepresentation(klass: FirRegularClass) {
private fun IrClass.declareValueClassRepresentation(klass: FirRegularClass) {
if (this !is Fir2IrLazyClass) {
inlineClassRepresentation = computeInlineClassRepresentation(klass)
valueClassRepresentation = computeValueClassRepresentation(klass)
}
}
@@ -216,7 +216,7 @@ class Fir2IrClassifierStorage(
irClass.declareTypeParameters(regularClass)
irClass.setThisReceiver(regularClass.typeParameters)
irClass.declareSupertypes(regularClass)
irClass.declareInlineClassRepresentation(regularClass)
irClass.declareValueClassRepresentation(regularClass)
return irClass
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt
+2 -7
View File
@@ -134,13 +134,8 @@ class Fir2IrLazyClass(
receiver
}
override var inlineClassRepresentation: InlineClassRepresentation<IrSimpleType>?
get() = computeInlineClassRepresentation(fir)
set(_) {
error("Mutating Fir2Ir lazy elements is not possible")
}
override var multiFieldValueClassRepresentation: MultiFieldValueClassRepresentation<IrSimpleType>?
get() = computeMultiFieldValueClassRepresentation(fir)
override var valueClassRepresentation: ValueClassRepresentation<IrSimpleType>?
get() = computeValueClassRepresentation(fir)
set(_) {
error("Mutating Fir2Ir lazy elements is not possible")
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/InlineClassesUtils.kt
-43
View File
@@ -1,43 +0,0 @@
/*
* Copyright 2010-2021 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 org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
import org.jetbrains.kotlin.fir.resolve.substitution.createTypeSubstitutorByTypeConstructor
import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.symbols.ensureResolved
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
import org.jetbrains.kotlin.fir.types.ConeTypeContext
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.types.model.typeConstructor
internal fun ConeKotlinType.substitutedUnderlyingTypeForInlineClass(session: FirSession, context: ConeTypeContext): ConeKotlinType? {
val unsubstitutedType = unsubstitutedUnderlyingTypeForInlineClass(session) ?: return null
val substitutor = createTypeSubstitutorByTypeConstructor(
mapOf(this.typeConstructor(context) to this), context, approximateIntegerLiterals = true
)
return substitutor.substituteOrNull(unsubstitutedType)
}
internal fun ConeKotlinType.unsubstitutedUnderlyingTypeForInlineClass(session: FirSession): ConeKotlinType? {
val symbol = (this.fullyExpandedType(session) as? ConeLookupTagBasedType)
?.lookupTag
?.toSymbol(session) as? FirRegularClassSymbol
?: return null
symbol.ensureResolved(FirResolvePhase.STATUS)
return symbol.fir.getInlineClassUnderlyingParameter(session)?.returnTypeRef?.coneType
}
// TODO: implement inlineClassRepresentation in FirRegularClass instead.
fun FirRegularClass.getInlineClassUnderlyingParameter(session: FirSession): FirValueParameter? =
if (isInline) primaryConstructorIfAny(session)?.fir?.valueParameters?.singleOrNull() else null
fun FirRegularClass.getMultiFieldValueClassUnderlyingParameters(session: FirSession): List<FirValueParameter>? =
if (isInline) primaryConstructorIfAny(session)?.fir?.valueParameters?.takeIf { it.size > 1 } else null
compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt
+14 -5
View File
@@ -9,6 +9,8 @@ import org.jetbrains.kotlin.builtins.PrimitiveType
import org.jetbrains.kotlin.builtins.StandardNames
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.ValueClassKind
import org.jetbrains.kotlin.descriptors.valueClassLoweringKind
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.*
@@ -22,10 +24,7 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
import org.jetbrains.kotlin.fir.symbols.ensureResolved
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.FqNameUnsafe
import org.jetbrains.kotlin.name.SpecialNames
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.name.*
import org.jetbrains.kotlin.types.TypeCheckerState
import org.jetbrains.kotlin.types.TypeCheckerState.SupertypesPolicy.DoCustomTransform
import org.jetbrains.kotlin.types.TypeCheckerState.SupertypesPolicy.LowerIfFlexible
@@ -552,7 +551,17 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
}
override fun TypeConstructorMarker.isInlineClass(): Boolean {
return toFirRegularClass()?.isInline == true
val fields = getValueClassProperties() ?: return false
return this@ConeTypeContext.valueClassLoweringKind(fields) == ValueClassKind.Inline
}
override fun TypeConstructorMarker.isMultiFieldValueClass(): Boolean {
val fields = getValueClassProperties() ?: return false
return this@ConeTypeContext.valueClassLoweringKind(fields) == ValueClassKind.MultiField
}
override fun TypeConstructorMarker.getValueClassProperties(): List<Pair<Name, SimpleTypeMarker>>? {
return toFirRegularClass()?.valueClassRepresentation?.underlyingPropertyNamesToTypes
}
override fun TypeConstructorMarker.isInnerClass(): Boolean {
compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt
+1 -2
View File
@@ -94,8 +94,7 @@ class SyntheticClassOrObjectDescriptor(
override fun getStaticScope() = MemberScope.Empty
override fun getUnsubstitutedMemberScope(kotlinTypeRefiner: KotlinTypeRefiner) = unsubstitutedMemberScope
override fun getSealedSubclasses() = emptyList<ClassDescriptor>()
override fun getInlineClassRepresentation(): InlineClassRepresentation<SimpleType>? = null
override fun getMultiFieldValueClassRepresentation(): MultiFieldValueClassRepresentation<SimpleType>? = null
override fun getValueClassRepresentation(): ValueClassRepresentation<SimpleType>? = null
init {
assert(modality != Modality.SEALED) { "Implement getSealedSubclasses() for this class: ${this::class.java}" }
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt
+1 -1
View File
@@ -271,7 +271,7 @@ class DeclarationsChecker(
if (declaration is KtPrimaryConstructor &&
!DescriptorUtils.isAnnotationClass(constructorDescriptor.constructedClass) &&
!constructorDescriptor.constructedClass.isInlineOrValueClass()
!constructorDescriptor.constructedClass.isValueClass()
) {
for (parameter in declaration.valueParameters) {
if (parameter.hasValOrVar()) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/InlineClassDescriptorResolver.kt
+1
View File
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
import org.jetbrains.kotlin.resolve.descriptorUtil.inlineClassRepresentation
import org.jetbrains.kotlin.types.KotlinType
object InlineClassDescriptorResolver {
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt
+4 -4
View File
@@ -77,7 +77,7 @@ object InlineClassDeclarationChecker : DeclarationChecker {
return
}
if (context.languageVersionSettings.supportsFeature(LanguageFeature.ValueClasses) && descriptor.isValueClass()) {
if (context.languageVersionSettings.supportsFeature(LanguageFeature.ValueClasses)) {
if (primaryConstructor.valueParameters.isEmpty()) {
(primaryConstructor.valueParameterList ?: declaration).let {
trace.report(Errors.VALUE_CLASS_EMPTY_CONSTRUCTOR.on(it))
@@ -176,7 +176,7 @@ class PropertiesWithBackingFieldsInsideInlineClass : DeclarationChecker {
if (declaration !is KtProperty) return
if (descriptor !is PropertyDescriptor) return
if (!descriptor.containingDeclaration.isInlineOrValueClass()) return
if (!descriptor.containingDeclaration.isValueClass()) return
if (context.trace.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor) == true) {
context.trace.report(Errors.PROPERTY_WITH_BACKING_FIELD_INSIDE_VALUE_CLASS.on(declaration))
@@ -194,7 +194,7 @@ class InnerClassInsideInlineClass : DeclarationChecker {
if (descriptor !is ClassDescriptor) return
if (!descriptor.isInner) return
if (!descriptor.containingDeclaration.isInlineOrValueClass()) return
if (!descriptor.containingDeclaration.isValueClass()) return
context.trace.report(Errors.INNER_CLASS_INSIDE_VALUE_CLASS.on(declaration.modifierList!!.getModifier(KtTokens.INNER_KEYWORD)!!))
}
@@ -208,7 +208,7 @@ class ReservedMembersAndConstructsForInlineClass : DeclarationChecker {
override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) {
val containingDeclaration = descriptor.containingDeclaration ?: return
if (!containingDeclaration.isInlineOrValueClass()) return
if (!containingDeclaration.isValueClass()) return
if (descriptor !is FunctionDescriptor) return
compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
+5 -5
View File
@@ -23,8 +23,6 @@ import org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.diagnostics.reportDiagnosticOnce
import org.jetbrains.kotlin.incremental.components.InlineConstTracker
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.resolve.descriptorUtil.isCompanionObject
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.parsing.*
@@ -32,15 +30,18 @@ import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
import org.jetbrains.kotlin.resolve.*
import org.jetbrains.kotlin.resolve.BindingContext.COLLECTION_LITERAL_CALL
import org.jetbrains.kotlin.resolve.calls.util.getEffectiveExpectedType
import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument
import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
import org.jetbrains.kotlin.resolve.calls.util.getEffectiveExpectedType
import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
import org.jetbrains.kotlin.resolve.checkers.ExperimentalUsageChecker
import org.jetbrains.kotlin.resolve.constants.*
import org.jetbrains.kotlin.resolve.constants.evaluate.CompileTimeType.*
import org.jetbrains.kotlin.resolve.descriptorUtil.classId
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
import org.jetbrains.kotlin.resolve.descriptorUtil.inlineClassRepresentation
import org.jetbrains.kotlin.resolve.descriptorUtil.isCompanionObject
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.SimpleType
import org.jetbrains.kotlin.types.TypeUtils
@@ -52,7 +53,6 @@ import org.jetbrains.kotlin.types.typeUtil.isBoolean
import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
import org.jetbrains.kotlin.util.OperatorNameConventions
import java.math.BigInteger
import java.util.*
class ConstantExpressionEvaluator(
internal val module: ModuleDescriptor,
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
+32 -28
View File
@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.annotations.Annotations;
import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase;
import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl;
import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl;
import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0;
import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
import org.jetbrains.kotlin.lexer.KtTokens;
@@ -41,7 +40,6 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProv
import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
import org.jetbrains.kotlin.resolve.scopes.MemberScope;
import org.jetbrains.kotlin.resolve.scopes.StaticScopeForKotlinEnum;
import org.jetbrains.kotlin.resolve.scopes.receivers.ContextClassReceiver;
import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt;
import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull;
import org.jetbrains.kotlin.storage.NotNullLazyValue;
@@ -631,43 +629,49 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
@Nullable
@Override
public InlineClassRepresentation<SimpleType> getInlineClassRepresentation() {
if (!InlineClassesUtilsKt.isInlineClass(this)) return null;
ClassConstructorDescriptor constructor = getUnsubstitutedPrimaryConstructor();
if (constructor != null) {
ValueParameterDescriptor parameter = firstOrNull(constructor.getValueParameters());
if (parameter != null) {
return new InlineClassRepresentation<>(parameter.getName(), (SimpleType) parameter.getType());
}
public ValueClassRepresentation<SimpleType> getValueClassRepresentation() {
if (!this.isValue && !this.isInline) {
return null;
}
ClassConstructorDescriptor constructor = getUnsubstitutedPrimaryConstructor();
// Don't crash on invalid code.
return new InlineClassRepresentation<>(
InlineClassRepresentation<SimpleType> invalidValueClassRepresentation = new InlineClassRepresentation<>(
SpecialNames.SAFE_IDENTIFIER_FOR_NO_NAME, c.getModuleDescriptor().getBuiltIns().getAnyType()
);
}
@Nullable
@Override
public MultiFieldValueClassRepresentation<SimpleType> getMultiFieldValueClassRepresentation() {
if (!InlineClassesUtilsKt.isValueClass(this) || InlineClassesUtilsKt.isInlineClass(this)) {
return null;
}
ClassConstructorDescriptor constructor = getUnsubstitutedPrimaryConstructor();
// Don't crash on invalid code. It is IC, not MFVC.
if (constructor == null) {
return null;
return invalidValueClassRepresentation;
}
List<ValueParameterDescriptor> parameters = constructor.getValueParameters();
if (parameters.size() <= 1) {
return null;
SimpleClassicTypeSystemContext context = SimpleClassicTypeSystemContext.INSTANCE;
if (isRecursiveInlineClass(constructor, new HashSet<>())) {
return new InlineClassRepresentation<>(parameters.get(0).getName(), (SimpleType) parameters.get(0).getType());
}
List<Pair<Name, SimpleType>> properties = parameters.stream()
if (parameters.size() == 0) {
return invalidValueClassRepresentation;
}
List<Pair<Name, SimpleType>> fields = parameters.stream()
.map(parameter -> new Pair<>(parameter.getName(), (SimpleType) parameter.getType()))
.collect(Collectors.toList());
return new MultiFieldValueClassRepresentation<>(properties);
return ValueClassRepresentationKt.createValueClassRepresentation(context, fields);
}
private static boolean isRecursiveInlineClass(@Nullable ClassConstructorDescriptor constructor, @NotNull Set<ClassDescriptor> visited) {
if (constructor == null || constructor.getValueParameters().size() != 1 ||
!(constructor.getConstructedClass().isValue() || constructor.getConstructedClass().isInline())) {
return false;
}
if (!visited.add(constructor.getConstructedClass())) {
return true;
}
SimpleType type = (SimpleType) constructor.getValueParameters().get(0).getType();
ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();
if (descriptor instanceof ClassDescriptor) {
ClassConstructorDescriptor newConstructor = ((ClassDescriptor) descriptor).getUnsubstitutedPrimaryConstructor();
return isRecursiveInlineClass(newConstructor, visited);
}
return false;
}
@Override
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
+3 -3
View File
@@ -296,7 +296,7 @@ open class LazyClassMemberScope(
}
result.addAll(generateDelegatingDescriptors(name, EXTRACT_FUNCTIONS, result))
generateDataClassMethods(result, name, location, fromSupertypes)
generateFunctionsFromAnyForInlineClass(result, name, fromSupertypes)
generateFunctionsFromAnyForValueClass(result, name, fromSupertypes)
c.syntheticResolveExtension.generateSyntheticMethods(thisDescriptor, name, trace.bindingContext, fromSupertypes, result)
c.additionalClassPartsProvider.generateAdditionalMethods(thisDescriptor, result, name, location, fromSupertypes)
@@ -304,12 +304,12 @@ open class LazyClassMemberScope(
generateFakeOverrides(name, fromSupertypes, result, SimpleFunctionDescriptor::class.java)
}
private fun generateFunctionsFromAnyForInlineClass(
private fun generateFunctionsFromAnyForValueClass(
result: MutableCollection<SimpleFunctionDescriptor>,
name: Name,
fromSupertypes: List<SimpleFunctionDescriptor>
) {
if (!thisDescriptor.isInlineOrValueClass()) return
if (!thisDescriptor.isValueClass()) return
FunctionsFromAny.addFunctionFromAnyIfNeeded(thisDescriptor, result, name, fromSupertypes)
}
compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/calls/EqualityAndComparisonCallsTransformer.kt
+2
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.ir.backend.js.lower.calls
import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
import org.jetbrains.kotlin.ir.backend.js.utils.isEqualsInheritedFromAny
@@ -17,6 +18,7 @@ import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
class EqualityAndComparisonCallsTransformer(context: JsIrBackendContext) : CallsTransformer {
compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineMultiFieldValueClassLowering.kt → compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt
+1 -1
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.backend.jvm.isMultiFieldValueClassFieldGetter
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.*
private class JvmInlineMultiFieldValueClassLowering(context: JvmBackendContext) : JvmValueClassAbstractLowering(context) {
private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmValueClassAbstractLowering(context) {
override val replacements: MemoizedValueClassAbstractReplacements
get() = context.multiFieldValueClassReplacements
compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt
-8
View File
@@ -121,14 +121,6 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon
protected abstract fun addJvmInlineAnnotation(valueClass: IrClass)
// abstract override fun visitFunctionReference(expression: IrFunctionReference): IrExpression
// abstract override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression
// abstract override fun visitCall(expression: IrCall): IrExpression
// abstract override fun visitGetField(expression: IrGetField): IrExpression
final override fun visitReturn(expression: IrReturn): IrExpression {
expression.returnTargetSymbol.owner.safeAs<IrFunction>()?.let { target ->
val suffix = target.hashSuffix()
compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt
+1 -2
View File
@@ -129,8 +129,7 @@ class JvmBackendContext(
val inlineClassReplacements = MemoizedInlineClassReplacements(state.functionsWithInlineClassReturnTypesMangled, irFactory, this)
val multiFieldValueClassReplacements =
MemoizedMultiFieldValueClassReplacements(state.functionsWithInlineClassReturnTypesMangled, irFactory, this)
val multiFieldValueClassReplacements = MemoizedMultiFieldValueClassReplacements(irFactory, this)
val continuationClassesVarsCountByType: MutableMap<IrAttributeContainer, Map<Type, Int>> = hashMapOf()
compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt
+1 -1
View File
@@ -273,7 +273,7 @@ class JvmSymbols(
private val resultClassStub: IrClassSymbol =
createClass(StandardNames.RESULT_FQ_NAME, classIsValue = true) { klass ->
klass.addTypeParameter("T", irBuiltIns.anyNType, Variance.OUT_VARIANCE)
klass.inlineClassRepresentation = InlineClassRepresentation(Name.identifier("value"), irBuiltIns.anyNType as IrSimpleType)
klass.valueClassRepresentation = InlineClassRepresentation(Name.identifier("value"), irBuiltIns.anyNType as IrSimpleType)
}
val resultOfAnyType: IrType = resultClassStub.typeWith(irBuiltIns.anyNType)
compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt
+1 -1
View File
@@ -40,7 +40,7 @@ class MemoizedInlineClassReplacements(
private val storageManager = LockBasedStorageManager("inline-class-replacements")
private val propertyMap = ConcurrentHashMap<IrPropertySymbol, IrProperty>()
val originalFunctionForStaticReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
override val originalFunctionForStaticReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
internal val originalFunctionForMethodReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
/**
compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt
+6 -276
View File
@@ -5,298 +5,28 @@
package org.jetbrains.kotlin.backend.jvm
import org.jetbrains.kotlin.backend.common.ir.copyTo
import org.jetbrains.kotlin.backend.common.ir.copyTypeParameters
import org.jetbrains.kotlin.backend.jvm.ir.*
import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.ir.builders.declarations.buildFun
import org.jetbrains.kotlin.ir.builders.declarations.buildProperty
import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
import org.jetbrains.kotlin.ir.types.isInt
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.ir.declarations.IrFactory
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
import org.jetbrains.kotlin.storage.LockBasedStorageManager
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
import java.util.concurrent.ConcurrentHashMap
/**
* Keeps track of replacement functions and multi-field value class box/unbox functions.
*/
class MemoizedMultiFieldValueClassReplacements(
private val mangleReturnTypes: Boolean, // todo always false
irFactory: IrFactory,
context: JvmBackendContext
) : MemoizedValueClassAbstractReplacements(irFactory, context) { // There is only sample logic yet
) : MemoizedValueClassAbstractReplacements(irFactory, context) {
private val storageManager = LockBasedStorageManager("multi-field-value-class-replacements")
private val propertyMap = ConcurrentHashMap<IrPropertySymbol, IrProperty>()
val originalFunctionForStaticReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
override val originalFunctionForStaticReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
internal val originalFunctionForMethodReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
/**
* Get a replacement for a function or a constructor.
*/
override val getReplacementFunction: (IrFunction) -> IrSimpleFunction? = storageManager.createMemoizedFunctionWithNullableValues {
when {
// Don't mangle anonymous or synthetic functions, except for generated SAM wrapper methods
(it.isLocal && it is IrSimpleFunction && it.overriddenSymbols.isEmpty()) ||
(it.origin == IrDeclarationOrigin.DELEGATED_PROPERTY_ACCESSOR && it.visibility == DescriptorVisibilities.LOCAL) ||
it.isStaticInlineClassReplacement ||
it.origin.isSynthetic && it.origin != IrDeclarationOrigin.SYNTHETIC_GENERATED_SAM_IMPLEMENTATION ->
null
it.isMultiFieldValueClassFieldGetter ->
if (it.hasMangledReturnType)
createMethodReplacement(it)
else
null
// Mangle all functions in the body of an inline class
it.parent.safeAs<IrClass>()?.isMultiFieldValueClass == true ->
when {
it.isRemoveAtSpecialBuiltinStub() ->
null
it.isInlineClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod() ||
it.origin == IrDeclarationOrigin.IR_BUILTINS_STUB ->
createMethodReplacement(it)
else ->
createStaticReplacement(it)
}
// Otherwise, mangle functions with mangled parameters, ignoring constructors
it is IrSimpleFunction && !it.isFromJava() && (it.hasMangledParameters || mangleReturnTypes && it.hasMangledReturnType) ->
createMethodReplacement(it)
else ->
null
}
}
private fun IrFunction.isRemoveAtSpecialBuiltinStub() =
origin == IrDeclarationOrigin.IR_BUILTINS_STUB &&
name.asString() == "remove" &&
valueParameters.size == 1 &&
valueParameters[0].type.isInt()
private fun IrFunction.isInlineClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod(): Boolean {
if (this !is IrSimpleFunction) return false
if (!this.isFakeOverride) return false
val parentClass = parentClassOrNull ?: return false
if (!parentClass.isMultiFieldValueClass) return false
val overridden = resolveFakeOverride() ?: return false
if (!overridden.parentAsClass.isJvmInterface) return false
if (overridden.modality == Modality.ABSTRACT) return false
// We have a non-abstract interface member.
// It is a JVM default interface method if one of the following conditions are true:
// - it is a Java method,
// - it is a Kotlin function compiled to JVM default interface method.
return overridden.isFromJava() || overridden.isCompiledToJvmDefault(context.state.jvmDefaultMode)
}
// /**
// * Get the box function for an inline class. Concretely, this is a synthetic
// * static function named "box-impl" which takes an unboxed value and returns
// * a boxed value.
// */
// val getBoxFunction: (IrClass) -> IrSimpleFunction =
// storageManager.createMemoizedFunction { irClass ->
// require(irClass.isSingleFieldValueClass)
// irFactory.buildFun {
// name = Name.identifier(KotlinTypeMapper.BOX_JVM_METHOD_NAME)
// origin = JvmLoweredDeclarationOrigin.SYNTHETIC_INLINE_CLASS_MEMBER
// returnType = irClass.defaultType
// }.apply {
// parent = irClass
// copyTypeParametersFrom(irClass)
// addValueParameter {
// name = InlineClassDescriptorResolver.BOXING_VALUE_PARAMETER_NAME
// type = irClass.inlineClassRepresentation!!.underlyingType
// }
// }
// }
//
// /**
// * Get the unbox function for an inline class. Concretely, this is a synthetic
// * member function named "unbox-impl" which returns an unboxed result.
// */
// val getUnboxFunction: (IrClass) -> IrSimpleFunction =
// storageManager.createMemoizedFunction { irClass ->
// require(irClass.isSingleFieldValueClass)
// irFactory.buildFun {
// name = Name.identifier(KotlinTypeMapper.UNBOX_JVM_METHOD_NAME)
// origin = JvmLoweredDeclarationOrigin.SYNTHETIC_INLINE_CLASS_MEMBER
// returnType = irClass.inlineClassRepresentation!!.underlyingType
// }.apply {
// parent = irClass
// createDispatchReceiverParameter()
// }
// }
//
// private val specializedEqualsCache = storageManager.createCacheWithNotNullValues<IrClass, IrSimpleFunction>()
// fun getSpecializedEqualsMethod(irClass: IrClass, irBuiltIns: IrBuiltIns): IrSimpleFunction {
// require(irClass.isSingleFieldValueClass)
// return specializedEqualsCache.computeIfAbsent(irClass) {
// irFactory.buildFun {
// name = InlineClassDescriptorResolver.SPECIALIZED_EQUALS_NAME
// // TODO: Revisit this once we allow user defined equals methods in inline classes.
// origin = JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD
// returnType = irBuiltIns.booleanType
// }.apply {
// parent = irClass
// // We ignore type arguments here, since there is no good way to go from type arguments to types in the IR anyway.
// val typeArgument =
// IrSimpleTypeImpl(null, irClass.symbol, false, List(irClass.typeParameters.size) { IrStarProjectionImpl }, listOf())
// addValueParameter {
// name = InlineClassDescriptorResolver.SPECIALIZED_EQUALS_FIRST_PARAMETER_NAME
// type = typeArgument
// }
// addValueParameter {
// name = InlineClassDescriptorResolver.SPECIALIZED_EQUALS_SECOND_PARAMETER_NAME
// type = typeArgument
// }
// }
// }
// }
private fun createMethodReplacement(function: IrFunction): IrSimpleFunction =
buildReplacement(function, function.origin) {
originalFunctionForMethodReplacement[this] = function
dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1)
extensionReceiverParameter = function.extensionReceiverParameter?.copyTo(
// The function's name will be mangled, so preserve the old receiver name.
this, index = -1, name = Name.identifier(function.extensionReceiverName(context.state))
)
contextReceiverParametersCount = function.contextReceiverParametersCount
valueParameters = function.valueParameters.mapIndexed { index, parameter ->
parameter.copyTo(this, index = index, defaultValue = null).also {
// Assuming that constructors and non-override functions are always replaced with the unboxed
// equivalent, deep-copying the value here is unnecessary. See `JvmInlineClassLowering`.
it.defaultValue = parameter.defaultValue?.patchDeclarationParents(this)
}
}
}
private fun createStaticReplacement(function: IrFunction): IrSimpleFunction =
buildReplacement(function, JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_REPLACEMENT, noFakeOverride = true) {
originalFunctionForStaticReplacement[this] = function
val newValueParameters = mutableListOf<IrValueParameter>()
if (function.dispatchReceiverParameter != null) {
// FAKE_OVERRIDEs have broken dispatch receivers
newValueParameters += function.parentAsClass.thisReceiver!!.copyTo(
this, index = newValueParameters.size, name = Name.identifier("arg${newValueParameters.size}"),
type = function.parentAsClass.defaultType, origin = IrDeclarationOrigin.MOVED_DISPATCH_RECEIVER
)
}
if (function.contextReceiverParametersCount != 0) {
function.valueParameters.take(function.contextReceiverParametersCount).forEachIndexed { i, contextReceiver ->
newValueParameters += contextReceiver.copyTo(
this, index = newValueParameters.size, name = Name.identifier("contextReceiver$i"),
origin = IrDeclarationOrigin.MOVED_CONTEXT_RECEIVER
)
}
}
function.extensionReceiverParameter?.let {
newValueParameters += it.copyTo(
this, index = newValueParameters.size, name = Name.identifier(function.extensionReceiverName(context.state)),
origin = IrDeclarationOrigin.MOVED_EXTENSION_RECEIVER
)
}
for (parameter in function.valueParameters.drop(function.contextReceiverParametersCount)) {
newValueParameters += parameter.copyTo(this, index = newValueParameters.size, defaultValue = null).also {
// See comment next to a similar line above.
it.defaultValue = parameter.defaultValue?.patchDeclarationParents(this)
}
}
valueParameters = newValueParameters
}
private fun buildReplacement(
function: IrFunction,
replacementOrigin: IrDeclarationOrigin,
noFakeOverride: Boolean = false,
body: IrFunction.() -> Unit
): IrSimpleFunction {
val useOldManglingScheme = context.state.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures
val replacement = buildReplacementInner(function, replacementOrigin, noFakeOverride, useOldManglingScheme, body)
// When using the new mangling scheme we might run into dependencies using the old scheme
// for which we will fall back to the old mangling scheme as well.
if (
!useOldManglingScheme &&
replacement.name.asString().contains("-") &&
function.parentClassId?.let { classFileContainsMethod(it, replacement, context) } == false
) {
return buildReplacementInner(function, replacementOrigin, noFakeOverride, true, body)
}
return replacement
}
private fun buildReplacementInner(
function: IrFunction,
replacementOrigin: IrDeclarationOrigin,
noFakeOverride: Boolean,
useOldManglingScheme: Boolean,
body: IrFunction.() -> Unit,
): IrSimpleFunction = irFactory.buildFun {
updateFrom(function)
if (function is IrConstructor) {
// The [updateFrom] call will set the modality to FINAL for constructors, while the JVM backend would use OPEN here.
modality = Modality.OPEN
}
origin = when {
function.origin == IrDeclarationOrigin.GENERATED_SINGLE_FIELD_VALUE_CLASS_MEMBER ->
JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD
function is IrConstructor && function.constructedClass.isSingleFieldValueClass ->
JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_CONSTRUCTOR
else ->
replacementOrigin
}
if (noFakeOverride) {
isFakeOverride = false
}
name = InlineClassAbi.mangledNameFor(function, mangleReturnTypes, useOldManglingScheme)
returnType = function.returnType
}.apply {
parent = function.parent
annotations = function.annotations
copyTypeParameters(function.allTypeParameters)
if (function.metadata != null) {
metadata = function.metadata
function.metadata = null
}
copyAttributes(function as? IrAttributeContainer)
if (function is IrSimpleFunction) {
val propertySymbol = function.correspondingPropertySymbol
if (propertySymbol != null) {
val property = propertyMap.getOrPut(propertySymbol) {
irFactory.buildProperty {
name = propertySymbol.owner.name
updateFrom(propertySymbol.owner)
}.apply {
parent = propertySymbol.owner.parent
copyAttributes(propertySymbol.owner)
annotations = propertySymbol.owner.annotations
backingField = propertySymbol.owner.backingField
}
}
correspondingPropertySymbol = property.symbol
when (function) {
propertySymbol.owner.getter -> property.getter = this
propertySymbol.owner.setter -> property.setter = this
else -> error("Orphaned property getter/setter: ${function.render()}")
}
}
overriddenSymbols = function.overriddenSymbols.map {
getReplacementFunction(it.owner)?.symbol ?: it
}
}
body()
TODO()
}
}
compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt
+3
View File
@@ -14,4 +14,7 @@ abstract class MemoizedValueClassAbstractReplacements(protected val irFactory: I
* Get a replacement for a function or a constructor.
*/
abstract val getReplacementFunction: (IrFunction) -> IrSimpleFunction?
abstract val originalFunctionForStaticReplacement: MutableMap<IrFunction, IrFunction>
}
compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt
+13 -8
View File
@@ -106,12 +106,11 @@ class ClassGenerator(
generateFakeOverrideMemberDeclarations(irClass, ktClassOrObject)
irClass.valueClassRepresentation = classDescriptor.valueClassRepresentation?.mapUnderlyingType { type ->
type.toIrType() as? IrSimpleType ?: error("Value class underlying type is not a simple type: $classDescriptor")
}
if (irClass.isSingleFieldValueClass && ktClassOrObject is KtClassOrObject) {
val representation = classDescriptor.inlineClassRepresentation
?: error("Unknown representation for inline class: $classDescriptor")
irClass.inlineClassRepresentation = representation.mapUnderlyingType { type ->
type.toIrType() as? IrSimpleType ?: error("Inline class underlying type is not a simple type: $classDescriptor")
}
generateAdditionalMembersForSingleFieldValueClasses(irClass, ktClassOrObject)
}
@@ -164,7 +163,11 @@ class ClassGenerator(
context.extensions.getParentClassStaticScope(classDescriptor)?.run {
for (parentStaticMember in getContributedDescriptors()) {
if (parentStaticMember is FunctionDescriptor &&
DescriptorVisibilityUtils.isVisibleIgnoringReceiver(parentStaticMember, classDescriptor, context.languageVersionSettings)
DescriptorVisibilityUtils.isVisibleIgnoringReceiver(
parentStaticMember,
classDescriptor,
context.languageVersionSettings
)
) {
val fakeOverride = createFakeOverrideDescriptorForParentStaticMember(classDescriptor, parentStaticMember)
declarationGenerator.generateFakeOverrideDeclaration(fakeOverride, ktClassOrObject)?.let {
@@ -523,8 +526,10 @@ class ClassGenerator(
if (!enumEntryDescriptor.isExpect) {
irEnumEntry.initializerExpression =
context.irFactory.createExpressionBody(createBodyGenerator(irEnumEntry.symbol)
.generateEnumEntryInitializer(ktEnumEntry, enumEntryDescriptor))
context.irFactory.createExpressionBody(
createBodyGenerator(irEnumEntry.symbol)
.generateEnumEntryInitializer(ktEnumEntry, enumEntryDescriptor)
)
}
if (ktEnumEntry.hasMemberDeclarations()) {
compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt
+1 -1
View File
@@ -97,7 +97,7 @@ class StandaloneDeclarationGenerator(private val context: GeneratorContext) {
descriptor.thisAsReceiverParameter.type.toIrType()
).also { it.parent = irClass }
irClass.inlineClassRepresentation = descriptor.inlineClassRepresentation?.mapUnderlyingType { it.toIrType() as IrSimpleType }
irClass.valueClassRepresentation = descriptor.valueClassRepresentation?.mapUnderlyingType { it.toIrType() as IrSimpleType }
}
return irClass
compiler/ir/ir.tree.impl/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt
+1 -3
View File
@@ -63,9 +63,7 @@ open class IrClassImpl(
override var superTypes: List<IrType> = emptyList()
override var inlineClassRepresentation: InlineClassRepresentation<IrSimpleType>? = null
override var multiFieldValueClassRepresentation: MultiFieldValueClassRepresentation<IrSimpleType>? = null
override var valueClassRepresentation: ValueClassRepresentation<IrSimpleType>? = null
override var metadata: MetadataSource? = null
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrClass.kt
+6 -2
View File
@@ -38,9 +38,13 @@ abstract class IrClass :
abstract var thisReceiver: IrValueParameter?
abstract var inlineClassRepresentation: InlineClassRepresentation<IrSimpleType>?
abstract var valueClassRepresentation: ValueClassRepresentation<IrSimpleType>?
abstract var multiFieldValueClassRepresentation: MultiFieldValueClassRepresentation<IrSimpleType>?
val inlineClassRepresentation: InlineClassRepresentation<IrSimpleType>?
get() = valueClassRepresentation as? InlineClassRepresentation<IrSimpleType>
val multiFieldValueClassRepresentation: MultiFieldValueClassRepresentation<IrSimpleType>?
get() = valueClassRepresentation as? MultiFieldValueClassRepresentation<IrSimpleType>
abstract var sealedSubclasses: List<IrClassSymbol>
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarations.kt
+4 -3
View File
@@ -5,10 +5,11 @@
package org.jetbrains.kotlin.ir.declarations
import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
import org.jetbrains.kotlin.descriptors.MultiFieldValueClassRepresentation
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
import org.jetbrains.kotlin.ir.util.primaryConstructor
import java.io.File
fun <D : IrAttributeContainer> D.copyAttributes(other: IrAttributeContainer?): D = apply {
@@ -18,10 +19,10 @@ fun <D : IrAttributeContainer> D.copyAttributes(other: IrAttributeContainer?): D
}
val IrClass.isSingleFieldValueClass: Boolean
get() = this.isValue && (this.inlineClassRepresentation != null || this.primaryConstructor?.valueParameters?.size == 1)
get() = valueClassRepresentation is InlineClassRepresentation
val IrClass.isMultiFieldValueClass: Boolean
get() = this.isValue && !isSingleFieldValueClass
get() = valueClassRepresentation is MultiFieldValueClassRepresentation
fun IrClass.addMember(member: IrDeclaration) {
declarations.add(member)
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt
+4 -10
View File
@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.metadata.ProtoBuf
import org.jetbrains.kotlin.metadata.deserialization.NameResolver
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
import org.jetbrains.kotlin.types.SimpleType
class IrLazyClass(
override val startOffset: Int,
@@ -101,15 +100,10 @@ class IrLazyClass(
}
}
override var inlineClassRepresentation: InlineClassRepresentation<IrSimpleType>? by lazyVar(stubGenerator.lock) {
descriptor.inlineClassRepresentation?.mapUnderlyingType(::simplyTypeToIrOrThrow)
}
private fun simplyTypeToIrOrThrow(it: SimpleType) =
it.toIrType() as? IrSimpleType ?: error("Inline class underlying type is not a simple type: ${render()}")
override var multiFieldValueClassRepresentation: MultiFieldValueClassRepresentation<IrSimpleType>? by lazyVar(stubGenerator.lock) {
descriptor.multiFieldValueClassRepresentation?.mapUnderlyingType(::simplyTypeToIrOrThrow)
override var valueClassRepresentation: ValueClassRepresentation<IrSimpleType>? by lazyVar(stubGenerator.lock) {
descriptor.valueClassRepresentation?.mapUnderlyingType {
it.toIrType() as? IrSimpleType ?: error("Value class underlying type is not a simple type: ${render()}")
}
}
override var attributeOwnerId: IrAttributeContainer = this
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBasedDescriptors.kt
+4 -12
View File
@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ
import org.jetbrains.kotlin.storage.LockBasedStorageManager
import org.jetbrains.kotlin.storage.StorageManager
import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.typeUtil.makeNullable
/* Descriptors that serve purely as a view into IR structures.
Created each time at the borderline between IR-based and descriptor-based code (such as inliner).
@@ -626,11 +625,8 @@ open class IrBasedClassDescriptor(owner: IrClass) : ClassDescriptor, IrBasedDecl
TODO("not implemented")
}
override fun getInlineClassRepresentation(): InlineClassRepresentation<SimpleType>? =
owner.inlineClassRepresentation?.mapUnderlyingType { it.toIrBasedKotlinType() as SimpleType }
override fun getMultiFieldValueClassRepresentation(): MultiFieldValueClassRepresentation<SimpleType>? =
owner.multiFieldValueClassRepresentation?.mapUnderlyingType { it.toIrBasedKotlinType() as SimpleType }
override fun getValueClassRepresentation(): ValueClassRepresentation<SimpleType>? =
owner.valueClassRepresentation?.mapUnderlyingType { it.toIrBasedKotlinType() as SimpleType }
override fun getOriginal() = this
@@ -756,13 +752,9 @@ open class IrBasedEnumEntryDescriptor(owner: IrEnumEntry) : ClassDescriptor, IrB
override fun getDeclaredTypeParameters(): List<TypeParameterDescriptor> = emptyList()
override fun getSealedSubclasses(): Collection<ClassDescriptor> {
TODO("not implemented")
}
override fun getSealedSubclasses(): Collection<ClassDescriptor> = TODO("not implemented")
override fun getInlineClassRepresentation(): InlineClassRepresentation<SimpleType>? = TODO("not implemented")
override fun getMultiFieldValueClassRepresentation(): MultiFieldValueClassRepresentation<SimpleType>? = TODO("not implemented")
override fun getValueClassRepresentation(): ValueClassRepresentation<SimpleType>? = TODO("not implemented")
override fun getOriginal() = this
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt
+6
View File
@@ -462,6 +462,12 @@ interface IrTypeSystemContext : TypeSystemContext, TypeSystemCommonSuperTypesCon
override fun TypeConstructorMarker.isInlineClass(): Boolean =
(this as? IrClassSymbol)?.owner?.isSingleFieldValueClass == true
override fun TypeConstructorMarker.isMultiFieldValueClass(): Boolean =
(this as? IrClassSymbol)?.owner?.isMultiFieldValueClass == true
override fun TypeConstructorMarker.valueClassRepresentationTypeMarkersList(): List<Pair<Name, SimpleTypeMarker>>? =
(this as? IrClassSymbol)?.owner?.valueClassRepresentation?.underlyingPropertyNamesToTypes
override fun TypeConstructorMarker.isInnerClass(): Boolean =
(this as? IrClassSymbol)?.owner?.isInner == true
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt
+2 -2
View File
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
import org.jetbrains.kotlin.resolve.DescriptorUtils
import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
import org.jetbrains.kotlin.resolve.isInlineOrValueClass
import org.jetbrains.kotlin.resolve.isValueClass
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -269,7 +269,7 @@ abstract class DeclarationStubGenerator(
isInner = descriptor.isInner,
isData = descriptor.isData,
isExternal = descriptor.isEffectivelyExternal(),
isValue = descriptor.isInlineOrValueClass(),
isValue = descriptor.isValueClass(),
isExpect = descriptor.isExpect,
isFun = descriptor.isFun,
stubGenerator = this,
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt
+1 -1
View File
@@ -159,7 +159,7 @@ open class DeepCopyIrTreeWithSymbols(
symbolRemapper.getReferencedClass(it)
}
thisReceiver = declaration.thisReceiver?.transform()
inlineClassRepresentation = declaration.inlineClassRepresentation?.mapUnderlyingType { it.remapType() as IrSimpleType }
valueClassRepresentation = declaration.valueClassRepresentation?.mapUnderlyingType { it.remapType() as IrSimpleType }
declaration.transformDeclarationsTo(this)
}.copyAttributes(declaration)
compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorToIrUtil.kt
+2 -2
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.ir.declarations.IrFactory
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
import org.jetbrains.kotlin.resolve.isInlineOrValueClass
import org.jetbrains.kotlin.resolve.isValueClass
import org.jetbrains.kotlin.types.KotlinType
val ParameterDescriptor.indexOrMinusOne: Int
@@ -39,5 +39,5 @@ fun IrFactory.createIrClassFromDescriptor(
): IrClass = createClass(
startOffset, endOffset, origin, symbol, name, descriptor.kind, visibility, modality,
descriptor.isCompanionObject, descriptor.isInner, descriptor.isData, descriptor.isEffectivelyExternal(),
descriptor.isInlineOrValueClass(), descriptor.isExpect, descriptor.isFun, descriptor.source
descriptor.isValueClass(), descriptor.isExpect, descriptor.isFun, descriptor.source
)
compiler/ir/serialization.common/src/KotlinIr.proto
+6
View File
@@ -533,6 +533,7 @@ message IrClass {
repeated IrDeclaration declaration = 5;
repeated int32 super_type = 6 [packed=true];
optional IrInlineClassRepresentation inline_class_representation = 7;
optional IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;
repeated int64 sealed_subclass = 8 [packed=true];
}
@@ -621,3 +622,8 @@ message IrInlineClassRepresentation {
required int32 underlying_property_name = 1;
required int32 underlying_property_type = 2;
}
message IrMultiFieldValueClassRepresentation {
repeated int32 underlying_property_name = 1 [packed=true];
repeated int32 underlying_property_type = 2 [packed=true];
}
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt
+14 -5
View File
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrType.KindCase.*
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.MultiFieldValueClassRepresentation
import org.jetbrains.kotlin.ir.IrBuiltIns
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.declarations.*
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
import org.jetbrains.kotlin.ir.symbols.*
import org.jetbrains.kotlin.ir.symbols.impl.IrPublicSymbolBase
import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterPublicSymbolImpl
import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
import org.jetbrains.kotlin.ir.types.*
import org.jetbrains.kotlin.ir.types.impl.*
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunction as Pro
import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionBase as ProtoFunctionBase
import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation
import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedProperty as ProtoLocalDelegatedProperty
import org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation as ProtoIrMultiFieldValueClassRepresentation
import org.jetbrains.kotlin.backend.common.serialization.proto.IrProperty as ProtoProperty
import org.jetbrains.kotlin.backend.common.serialization.proto.IrSimpleType as ProtoSimpleType
import org.jetbrains.kotlin.backend.common.serialization.proto.IrStatement as ProtoStatement
@@ -347,14 +348,16 @@ class IrDeclarationDeserializer(
thisReceiver = deserializeIrValueParameter(proto.thisReceiver, -1)
inlineClassRepresentation = when {
!(flags.isValue && primaryConstructor?.valueParameters?.size == 1) -> null
valueClassRepresentation = when {
!flags.isValue -> null
proto.hasMultiFieldValueClassRepresentation() && proto.hasInlineClassRepresentation() ->
error("Class cannot be both inline and multi-field value: $name")
proto.hasInlineClassRepresentation() -> deserializeInlineClassRepresentation(proto.inlineClassRepresentation)
proto.hasMultiFieldValueClassRepresentation() ->
deserializeMultiFieldValueClassRepresentation(proto.multiFieldValueClassRepresentation)
else -> computeMissingInlineClassRepresentationForCompatibility(this)
}
// todo something when value classes
sealedSubclasses = proto.sealedSubclassList.map { deserializeIrSymbol(it) as IrClassSymbol }
fakeOverrideBuilder.enqueueClass(this, signature, compatibilityMode)
@@ -367,6 +370,12 @@ class IrDeclarationDeserializer(
deserializeIrType(proto.underlyingPropertyType) as IrSimpleType,
)
private fun deserializeMultiFieldValueClassRepresentation(proto: ProtoIrMultiFieldValueClassRepresentation): MultiFieldValueClassRepresentation<IrSimpleType> {
val names = proto.underlyingPropertyNameList.map { deserializeName(it) }
val types = proto.underlyingPropertyTypeList.map { deserializeIrType(it) as IrSimpleType }
return MultiFieldValueClassRepresentation(names zip types)
}
private fun computeMissingInlineClassRepresentationForCompatibility(irClass: IrClass): InlineClassRepresentation<IrSimpleType> {
// For inline classes compiled with 1.5.20 or earlier, try to reconstruct inline class representation from the single parameter of
// the primary constructor. Something similar is happening in `DeserializedClassDescriptor.computeInlineClassRepresentation`.
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt
+16 -8
View File
@@ -6,10 +6,7 @@
package org.jetbrains.kotlin.backend.common.serialization
import org.jetbrains.kotlin.backend.common.serialization.encodings.*
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.ir.IrElement
import org.jetbrains.kotlin.ir.IrFileEntry
import org.jetbrains.kotlin.ir.declarations.*
@@ -83,6 +80,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepr
import org.jetbrains.kotlin.backend.common.serialization.proto.IrInstanceInitializerCall as ProtoInstanceInitializerCall
import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedProperty as ProtoLocalDelegatedProperty
import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedPropertyReference as ProtoLocalDelegatedPropertyReference
import org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation as ProtoIrMultiFieldValueClassRepresentation
import org.jetbrains.kotlin.backend.common.serialization.proto.IrOperation as ProtoOperation
import org.jetbrains.kotlin.backend.common.serialization.proto.IrProperty as ProtoProperty
import org.jetbrains.kotlin.backend.common.serialization.proto.IrPropertyReference as ProtoPropertyReference
@@ -1031,7 +1029,8 @@ open class IrFileSerializer(
is IrGetEnumValue -> operationProto.getEnumValue = serializeGetEnumValue(expression)
is IrGetObjectValue -> operationProto.getObject = serializeGetObject(expression)
is IrInstanceInitializerCall -> operationProto.instanceInitializerCall = serializeInstanceInitializerCall(expression)
is IrLocalDelegatedPropertyReference -> operationProto.localDelegatedPropertyReference = serializeIrLocalDelegatedPropertyReference(expression)
is IrLocalDelegatedPropertyReference -> operationProto.localDelegatedPropertyReference =
serializeIrLocalDelegatedPropertyReference(expression)
is IrPropertyReference -> operationProto.propertyReference = serializePropertyReference(expression)
is IrReturn -> serializeReturn(operationProto, expression)
is IrSetField -> operationProto.setField = serializeSetField(expression)
@@ -1234,9 +1233,12 @@ open class IrFileSerializer(
.setBase(serializeIrDeclarationBase(clazz, ClassFlags.encode(clazz)))
.setName(serializeName(clazz.name))
val representation = clazz.inlineClassRepresentation
if (representation != null) {
proto.inlineClassRepresentation = serializeInlineClassRepresentation(representation)
when (val representation = clazz.valueClassRepresentation) {
is MultiFieldValueClassRepresentation ->
proto.multiFieldValueClassRepresentation = serializeMultiFieldValueClassRepresentation(representation)
is InlineClassRepresentation -> proto.inlineClassRepresentation = serializeInlineClassRepresentation(representation)
null -> Unit
}
clazz.declarations.forEach {
@@ -1267,6 +1269,12 @@ open class IrFileSerializer(
underlyingPropertyType = serializeIrType(representation.underlyingType)
}.build()
private fun serializeMultiFieldValueClassRepresentation(representation: MultiFieldValueClassRepresentation<IrSimpleType>): ProtoIrMultiFieldValueClassRepresentation =
ProtoIrMultiFieldValueClassRepresentation.newBuilder().apply {
addAllUnderlyingPropertyName(representation.underlyingPropertyNamesToTypes.map { (name, _) -> serializeName(name) })
addAllUnderlyingPropertyType(representation.underlyingPropertyNamesToTypes.map { (_, irType) -> serializeIrType(irType) })
}.build()
private fun serializeIrTypeAlias(typeAlias: IrTypeAlias): ProtoTypeAlias {
val proto = ProtoTypeAlias.newBuilder()
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClass.java
+117 -12
View File
@@ -135,9 +135,9 @@ public final class IrClass extends
break;
}
case 64: {
if (!((mutable_bitField0_ & 0x00000080) == 0x00000080)) {
if (!((mutable_bitField0_ & 0x00000100) == 0x00000100)) {
sealedSubclass_ = new java.util.ArrayList<java.lang.Long>();
mutable_bitField0_ |= 0x00000080;
mutable_bitField0_ |= 0x00000100;
}
sealedSubclass_.add(input.readInt64());
break;
@@ -145,9 +145,9 @@ public final class IrClass extends
case 66: {
int length = input.readRawVarint32();
int limit = input.pushLimit(length);
if (!((mutable_bitField0_ & 0x00000080) == 0x00000080) && input.getBytesUntilLimit() > 0) {
if (!((mutable_bitField0_ & 0x00000100) == 0x00000100) && input.getBytesUntilLimit() > 0) {
sealedSubclass_ = new java.util.ArrayList<java.lang.Long>();
mutable_bitField0_ |= 0x00000080;
mutable_bitField0_ |= 0x00000100;
}
while (input.getBytesUntilLimit() > 0) {
sealedSubclass_.add(input.readInt64());
@@ -155,6 +155,19 @@ public final class IrClass extends
input.popLimit(limit);
break;
}
case 74: {
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.Builder subBuilder = null;
if (((bitField0_ & 0x00000010) == 0x00000010)) {
subBuilder = multiFieldValueClassRepresentation_.toBuilder();
}
multiFieldValueClassRepresentation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.PARSER, extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(multiFieldValueClassRepresentation_);
multiFieldValueClassRepresentation_ = subBuilder.buildPartial();
}
bitField0_ |= 0x00000010;
break;
}
}
}
} catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -172,7 +185,7 @@ public final class IrClass extends
if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
superType_ = java.util.Collections.unmodifiableList(superType_);
}
if (((mutable_bitField0_ & 0x00000080) == 0x00000080)) {
if (((mutable_bitField0_ & 0x00000100) == 0x00000100)) {
sealedSubclass_ = java.util.Collections.unmodifiableList(sealedSubclass_);
}
try {
@@ -354,6 +367,21 @@ public final class IrClass extends
return inlineClassRepresentation_;
}
public static final int MULTI_FIELD_VALUE_CLASS_REPRESENTATION_FIELD_NUMBER = 9;
private org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multiFieldValueClassRepresentation_;
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public boolean hasMultiFieldValueClassRepresentation() {
return ((bitField0_ & 0x00000010) == 0x00000010);
}
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getMultiFieldValueClassRepresentation() {
return multiFieldValueClassRepresentation_;
}
public static final int SEALED_SUBCLASS_FIELD_NUMBER = 8;
private java.util.List<java.lang.Long> sealedSubclass_;
/**
@@ -385,6 +413,7 @@ public final class IrClass extends
declaration_ = java.util.Collections.emptyList();
superType_ = java.util.Collections.emptyList();
inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance();
multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
sealedSubclass_ = java.util.Collections.emptyList();
}
private byte memoizedIsInitialized = -1;
@@ -468,6 +497,9 @@ public final class IrClass extends
for (int i = 0; i < sealedSubclass_.size(); i++) {
output.writeInt64NoTag(sealedSubclass_.get(i));
}
if (((bitField0_ & 0x00000010) == 0x00000010)) {
output.writeMessage(9, multiFieldValueClassRepresentation_);
}
output.writeRawBytes(unknownFields);
}
@@ -529,6 +561,10 @@ public final class IrClass extends
}
sealedSubclassMemoizedSerializedSize = dataSize;
}
if (((bitField0_ & 0x00000010) == 0x00000010)) {
size += org.jetbrains.kotlin.protobuf.CodedOutputStream
.computeMessageSize(9, multiFieldValueClassRepresentation_);
}
size += unknownFields.size();
memoizedSerializedSize = size;
return size;
@@ -637,8 +673,10 @@ public final class IrClass extends
bitField0_ = (bitField0_ & ~0x00000020);
inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance();
bitField0_ = (bitField0_ & ~0x00000040);
sealedSubclass_ = java.util.Collections.emptyList();
multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
bitField0_ = (bitField0_ & ~0x00000080);
sealedSubclass_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000100);
return this;
}
@@ -693,9 +731,13 @@ public final class IrClass extends
to_bitField0_ |= 0x00000008;
}
result.inlineClassRepresentation_ = inlineClassRepresentation_;
if (((bitField0_ & 0x00000080) == 0x00000080)) {
if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
to_bitField0_ |= 0x00000010;
}
result.multiFieldValueClassRepresentation_ = multiFieldValueClassRepresentation_;
if (((bitField0_ & 0x00000100) == 0x00000100)) {
sealedSubclass_ = java.util.Collections.unmodifiableList(sealedSubclass_);
bitField0_ = (bitField0_ & ~0x00000080);
bitField0_ = (bitField0_ & ~0x00000100);
}
result.sealedSubclass_ = sealedSubclass_;
result.bitField0_ = to_bitField0_;
@@ -746,10 +788,13 @@ public final class IrClass extends
if (other.hasInlineClassRepresentation()) {
mergeInlineClassRepresentation(other.getInlineClassRepresentation());
}
if (other.hasMultiFieldValueClassRepresentation()) {
mergeMultiFieldValueClassRepresentation(other.getMultiFieldValueClassRepresentation());
}
if (!other.sealedSubclass_.isEmpty()) {
if (sealedSubclass_.isEmpty()) {
sealedSubclass_ = other.sealedSubclass_;
bitField0_ = (bitField0_ & ~0x00000080);
bitField0_ = (bitField0_ & ~0x00000100);
} else {
ensureSealedSubclassIsMutable();
sealedSubclass_.addAll(other.sealedSubclass_);
@@ -1348,11 +1393,71 @@ public final class IrClass extends
return this;
}
private org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public boolean hasMultiFieldValueClassRepresentation() {
return ((bitField0_ & 0x00000080) == 0x00000080);
}
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getMultiFieldValueClassRepresentation() {
return multiFieldValueClassRepresentation_;
}
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public Builder setMultiFieldValueClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation value) {
if (value == null) {
throw new NullPointerException();
}
multiFieldValueClassRepresentation_ = value;
bitField0_ |= 0x00000080;
return this;
}
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public Builder setMultiFieldValueClassRepresentation(
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.Builder builderForValue) {
multiFieldValueClassRepresentation_ = builderForValue.build();
bitField0_ |= 0x00000080;
return this;
}
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public Builder mergeMultiFieldValueClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation value) {
if (((bitField0_ & 0x00000080) == 0x00000080) &&
multiFieldValueClassRepresentation_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance()) {
multiFieldValueClassRepresentation_ =
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.newBuilder(multiFieldValueClassRepresentation_).mergeFrom(value).buildPartial();
} else {
multiFieldValueClassRepresentation_ = value;
}
bitField0_ |= 0x00000080;
return this;
}
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
public Builder clearMultiFieldValueClassRepresentation() {
multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
bitField0_ = (bitField0_ & ~0x00000080);
return this;
}
private java.util.List<java.lang.Long> sealedSubclass_ = java.util.Collections.emptyList();
private void ensureSealedSubclassIsMutable() {
if (!((bitField0_ & 0x00000080) == 0x00000080)) {
if (!((bitField0_ & 0x00000100) == 0x00000100)) {
sealedSubclass_ = new java.util.ArrayList<java.lang.Long>(sealedSubclass_);
bitField0_ |= 0x00000080;
bitField0_ |= 0x00000100;
}
}
/**
@@ -1409,7 +1514,7 @@ public final class IrClass extends
*/
public Builder clearSealedSubclass() {
sealedSubclass_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000080);
bitField0_ = (bitField0_ & ~0x00000100);
return this;
}
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrClassOrBuilder.java
+9
View File
@@ -84,6 +84,15 @@ public interface IrClassOrBuilder extends
*/
org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation();
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
boolean hasMultiFieldValueClassRepresentation();
/**
* <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
*/
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getMultiFieldValueClassRepresentation();
/**
* <code>repeated int64 sealed_subclass = 8 [packed = true];</code>
*/
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrMultiFieldValueClassRepresentation.java
+575
View File
@@ -0,0 +1,575 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: compiler/ir/serialization.common/src/KotlinIr.proto
package org.jetbrains.kotlin.backend.common.serialization.proto;
/**
* Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation}
*/
public final class IrMultiFieldValueClassRepresentation extends
org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
// @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
IrMultiFieldValueClassRepresentationOrBuilder {
// Use IrMultiFieldValueClassRepresentation.newBuilder() to construct.
private IrMultiFieldValueClassRepresentation(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
private IrMultiFieldValueClassRepresentation(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
private static final IrMultiFieldValueClassRepresentation defaultInstance;
public static IrMultiFieldValueClassRepresentation getDefaultInstance() {
return defaultInstance;
}
public IrMultiFieldValueClassRepresentation getDefaultInstanceForType() {
return defaultInstance;
}
private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
private IrMultiFieldValueClassRepresentation(
org.jetbrains.kotlin.protobuf.CodedInputStream input,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
initFields();
int mutable_bitField0_ = 0;
org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
org.jetbrains.kotlin.protobuf.ByteString.newOutput();
org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
unknownFieldsOutput, 1);
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownField(input, unknownFieldsCodedOutput,
extensionRegistry, tag)) {
done = true;
}
break;
}
case 8: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
underlyingPropertyName_ = new java.util.ArrayList<java.lang.Integer>();
mutable_bitField0_ |= 0x00000001;
}
underlyingPropertyName_.add(input.readInt32());
break;
}
case 10: {
int length = input.readRawVarint32();
int limit = input.pushLimit(length);
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
underlyingPropertyName_ = new java.util.ArrayList<java.lang.Integer>();
mutable_bitField0_ |= 0x00000001;
}
while (input.getBytesUntilLimit() > 0) {
underlyingPropertyName_.add(input.readInt32());
}
input.popLimit(limit);
break;
}
case 16: {
if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
underlyingPropertyType_ = new java.util.ArrayList<java.lang.Integer>();
mutable_bitField0_ |= 0x00000002;
}
underlyingPropertyType_.add(input.readInt32());
break;
}
case 18: {
int length = input.readRawVarint32();
int limit = input.pushLimit(length);
if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
underlyingPropertyType_ = new java.util.ArrayList<java.lang.Integer>();
mutable_bitField0_ |= 0x00000002;
}
while (input.getBytesUntilLimit() > 0) {
underlyingPropertyType_.add(input.readInt32());
}
input.popLimit(limit);
break;
}
}
}
} catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
e.getMessage()).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
underlyingPropertyName_ = java.util.Collections.unmodifiableList(underlyingPropertyName_);
}
if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
underlyingPropertyType_ = java.util.Collections.unmodifiableList(underlyingPropertyType_);
}
try {
unknownFieldsCodedOutput.flush();
} catch (java.io.IOException e) {
// Should not happen
} finally {
unknownFields = unknownFieldsOutput.toByteString();
}
makeExtensionsImmutable();
}
}
public static org.jetbrains.kotlin.protobuf.Parser<IrMultiFieldValueClassRepresentation> PARSER =
new org.jetbrains.kotlin.protobuf.AbstractParser<IrMultiFieldValueClassRepresentation>() {
public IrMultiFieldValueClassRepresentation parsePartialFrom(
org.jetbrains.kotlin.protobuf.CodedInputStream input,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
return new IrMultiFieldValueClassRepresentation(input, extensionRegistry);
}
};
@java.lang.Override
public org.jetbrains.kotlin.protobuf.Parser<IrMultiFieldValueClassRepresentation> getParserForType() {
return PARSER;
}
public static final int UNDERLYING_PROPERTY_NAME_FIELD_NUMBER = 1;
private java.util.List<java.lang.Integer> underlyingPropertyName_;
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public java.util.List<java.lang.Integer>
getUnderlyingPropertyNameList() {
return underlyingPropertyName_;
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public int getUnderlyingPropertyNameCount() {
return underlyingPropertyName_.size();
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public int getUnderlyingPropertyName(int index) {
return underlyingPropertyName_.get(index);
}
private int underlyingPropertyNameMemoizedSerializedSize = -1;
public static final int UNDERLYING_PROPERTY_TYPE_FIELD_NUMBER = 2;
private java.util.List<java.lang.Integer> underlyingPropertyType_;
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public java.util.List<java.lang.Integer>
getUnderlyingPropertyTypeList() {
return underlyingPropertyType_;
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public int getUnderlyingPropertyTypeCount() {
return underlyingPropertyType_.size();
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public int getUnderlyingPropertyType(int index) {
return underlyingPropertyType_.get(index);
}
private int underlyingPropertyTypeMemoizedSerializedSize = -1;
private void initFields() {
underlyingPropertyName_ = java.util.Collections.emptyList();
underlyingPropertyType_ = java.util.Collections.emptyList();
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output)
throws java.io.IOException {
getSerializedSize();
if (getUnderlyingPropertyNameList().size() > 0) {
output.writeRawVarint32(10);
output.writeRawVarint32(underlyingPropertyNameMemoizedSerializedSize);
}
for (int i = 0; i < underlyingPropertyName_.size(); i++) {
output.writeInt32NoTag(underlyingPropertyName_.get(i));
}
if (getUnderlyingPropertyTypeList().size() > 0) {
output.writeRawVarint32(18);
output.writeRawVarint32(underlyingPropertyTypeMemoizedSerializedSize);
}
for (int i = 0; i < underlyingPropertyType_.size(); i++) {
output.writeInt32NoTag(underlyingPropertyType_.get(i));
}
output.writeRawBytes(unknownFields);
}
private int memoizedSerializedSize = -1;
public int getSerializedSize() {
int size = memoizedSerializedSize;
if (size != -1) return size;
size = 0;
{
int dataSize = 0;
for (int i = 0; i < underlyingPropertyName_.size(); i++) {
dataSize += org.jetbrains.kotlin.protobuf.CodedOutputStream
.computeInt32SizeNoTag(underlyingPropertyName_.get(i));
}
size += dataSize;
if (!getUnderlyingPropertyNameList().isEmpty()) {
size += 1;
size += org.jetbrains.kotlin.protobuf.CodedOutputStream
.computeInt32SizeNoTag(dataSize);
}
underlyingPropertyNameMemoizedSerializedSize = dataSize;
}
{
int dataSize = 0;
for (int i = 0; i < underlyingPropertyType_.size(); i++) {
dataSize += org.jetbrains.kotlin.protobuf.CodedOutputStream
.computeInt32SizeNoTag(underlyingPropertyType_.get(i));
}
size += dataSize;
if (!getUnderlyingPropertyTypeList().isEmpty()) {
size += 1;
size += org.jetbrains.kotlin.protobuf.CodedOutputStream
.computeInt32SizeNoTag(dataSize);
}
underlyingPropertyTypeMemoizedSerializedSize = dataSize;
}
size += unknownFields.size();
memoizedSerializedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(
org.jetbrains.kotlin.protobuf.ByteString data)
throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(
org.jetbrains.kotlin.protobuf.ByteString data,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(byte[] data)
throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(
byte[] data,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(java.io.InputStream input)
throws java.io.IOException {
return PARSER.parseFrom(input);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(
java.io.InputStream input,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseDelimitedFrom(
java.io.InputStream input,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(
org.jetbrains.kotlin.protobuf.CodedInputStream input)
throws java.io.IOException {
return PARSER.parseFrom(input);
}
public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parseFrom(
org.jetbrains.kotlin.protobuf.CodedInputStream input,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
public static Builder newBuilder() { return Builder.create(); }
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation prototype) {
return newBuilder().mergeFrom(prototype);
}
public Builder toBuilder() { return newBuilder(this); }
/**
* Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation}
*/
public static final class Builder extends
org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation, Builder>
implements
// @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentationOrBuilder {
// Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
}
private static Builder create() {
return new Builder();
}
public Builder clear() {
super.clear();
underlyingPropertyName_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
underlyingPropertyType_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000002);
return this;
}
public Builder clone() {
return create().mergeFrom(buildPartial());
}
public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getDefaultInstanceForType() {
return org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
}
public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation build() {
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation buildPartial() {
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation(this);
int from_bitField0_ = bitField0_;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
underlyingPropertyName_ = java.util.Collections.unmodifiableList(underlyingPropertyName_);
bitField0_ = (bitField0_ & ~0x00000001);
}
result.underlyingPropertyName_ = underlyingPropertyName_;
if (((bitField0_ & 0x00000002) == 0x00000002)) {
underlyingPropertyType_ = java.util.Collections.unmodifiableList(underlyingPropertyType_);
bitField0_ = (bitField0_ & ~0x00000002);
}
result.underlyingPropertyType_ = underlyingPropertyType_;
return result;
}
public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation other) {
if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance()) return this;
if (!other.underlyingPropertyName_.isEmpty()) {
if (underlyingPropertyName_.isEmpty()) {
underlyingPropertyName_ = other.underlyingPropertyName_;
bitField0_ = (bitField0_ & ~0x00000001);
} else {
ensureUnderlyingPropertyNameIsMutable();
underlyingPropertyName_.addAll(other.underlyingPropertyName_);
}
}
if (!other.underlyingPropertyType_.isEmpty()) {
if (underlyingPropertyType_.isEmpty()) {
underlyingPropertyType_ = other.underlyingPropertyType_;
bitField0_ = (bitField0_ & ~0x00000002);
} else {
ensureUnderlyingPropertyTypeIsMutable();
underlyingPropertyType_.addAll(other.underlyingPropertyType_);
}
}
setUnknownFields(
getUnknownFields().concat(other.unknownFields));
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
org.jetbrains.kotlin.protobuf.CodedInputStream input,
org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int bitField0_;
private java.util.List<java.lang.Integer> underlyingPropertyName_ = java.util.Collections.emptyList();
private void ensureUnderlyingPropertyNameIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
underlyingPropertyName_ = new java.util.ArrayList<java.lang.Integer>(underlyingPropertyName_);
bitField0_ |= 0x00000001;
}
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public java.util.List<java.lang.Integer>
getUnderlyingPropertyNameList() {
return java.util.Collections.unmodifiableList(underlyingPropertyName_);
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public int getUnderlyingPropertyNameCount() {
return underlyingPropertyName_.size();
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public int getUnderlyingPropertyName(int index) {
return underlyingPropertyName_.get(index);
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public Builder setUnderlyingPropertyName(
int index, int value) {
ensureUnderlyingPropertyNameIsMutable();
underlyingPropertyName_.set(index, value);
return this;
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public Builder addUnderlyingPropertyName(int value) {
ensureUnderlyingPropertyNameIsMutable();
underlyingPropertyName_.add(value);
return this;
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public Builder addAllUnderlyingPropertyName(
java.lang.Iterable<? extends java.lang.Integer> values) {
ensureUnderlyingPropertyNameIsMutable();
org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
values, underlyingPropertyName_);
return this;
}
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
public Builder clearUnderlyingPropertyName() {
underlyingPropertyName_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000001);
return this;
}
private java.util.List<java.lang.Integer> underlyingPropertyType_ = java.util.Collections.emptyList();
private void ensureUnderlyingPropertyTypeIsMutable() {
if (!((bitField0_ & 0x00000002) == 0x00000002)) {
underlyingPropertyType_ = new java.util.ArrayList<java.lang.Integer>(underlyingPropertyType_);
bitField0_ |= 0x00000002;
}
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public java.util.List<java.lang.Integer>
getUnderlyingPropertyTypeList() {
return java.util.Collections.unmodifiableList(underlyingPropertyType_);
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public int getUnderlyingPropertyTypeCount() {
return underlyingPropertyType_.size();
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public int getUnderlyingPropertyType(int index) {
return underlyingPropertyType_.get(index);
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public Builder setUnderlyingPropertyType(
int index, int value) {
ensureUnderlyingPropertyTypeIsMutable();
underlyingPropertyType_.set(index, value);
return this;
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public Builder addUnderlyingPropertyType(int value) {
ensureUnderlyingPropertyTypeIsMutable();
underlyingPropertyType_.add(value);
return this;
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public Builder addAllUnderlyingPropertyType(
java.lang.Iterable<? extends java.lang.Integer> values) {
ensureUnderlyingPropertyTypeIsMutable();
org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
values, underlyingPropertyType_);
return this;
}
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
public Builder clearUnderlyingPropertyType() {
underlyingPropertyType_ = java.util.Collections.emptyList();
bitField0_ = (bitField0_ & ~0x00000002);
return this;
}
// @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
}
static {
defaultInstance = new IrMultiFieldValueClassRepresentation(true);
defaultInstance.initFields();
}
// @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
}
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrMultiFieldValueClassRepresentationOrBuilder.java
+35
View File
@@ -0,0 +1,35 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: compiler/ir/serialization.common/src/KotlinIr.proto
package org.jetbrains.kotlin.backend.common.serialization.proto;
public interface IrMultiFieldValueClassRepresentationOrBuilder extends
// @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
java.util.List<java.lang.Integer> getUnderlyingPropertyNameList();
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
int getUnderlyingPropertyNameCount();
/**
* <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
*/
int getUnderlyingPropertyName(int index);
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
java.util.List<java.lang.Integer> getUnderlyingPropertyTypeList();
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
int getUnderlyingPropertyTypeCount();
/**
* <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
*/
int getUnderlyingPropertyType(int index);
}
compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt
+20 -8
View File
@@ -31,6 +31,8 @@ import org.jetbrains.kotlin.resolve.constants.EnumValue
import org.jetbrains.kotlin.resolve.constants.IntValue
import org.jetbrains.kotlin.resolve.constants.NullValue
import org.jetbrains.kotlin.resolve.constants.StringValue
import org.jetbrains.kotlin.resolve.descriptorUtil.inlineClassRepresentation
import org.jetbrains.kotlin.resolve.descriptorUtil.multiFieldValueClassRepresentation
import org.jetbrains.kotlin.resolve.descriptorUtil.nonSourceAnnotations
import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
@@ -92,7 +94,7 @@ class DescriptorSerializer private constructor(
ProtoEnumFlags.modality(classDescriptor.modality),
ProtoEnumFlags.classKind(classDescriptor.kind, classDescriptor.isCompanionObject),
classDescriptor.isInner, classDescriptor.isData, classDescriptor.isExternal, classDescriptor.isExpect,
classDescriptor.isInlineOrValueClass(), classDescriptor.isFun
classDescriptor.isValueClass(), classDescriptor.isFun
)
if (flags != builder.flags) {
builder.flags = flags
@@ -171,22 +173,31 @@ class DescriptorSerializer private constructor(
builder.companionObjectName = getSimpleNameIndex(companionObjectDescriptor.name)
}
val representation = classDescriptor.inlineClassRepresentation
if (representation != null) {
builder.inlineClassUnderlyingPropertyName = getSimpleNameIndex(representation.underlyingPropertyName)
classDescriptor.inlineClassRepresentation?.let { inlineClassRepresentation ->
builder.inlineClassUnderlyingPropertyName = getSimpleNameIndex(inlineClassRepresentation.underlyingPropertyName)
val property = callableMembers.single {
it is PropertyDescriptor && it.extensionReceiverParameter == null && it.name == representation.underlyingPropertyName
it is PropertyDescriptor && it.extensionReceiverParameter == null && it.name == inlineClassRepresentation.underlyingPropertyName
}
if (!property.visibility.isPublicAPI) {
if (useTypeTable()) {
builder.inlineClassUnderlyingTypeId = typeId(representation.underlyingType)
builder.inlineClassUnderlyingTypeId = typeId(inlineClassRepresentation.underlyingType)
} else {
builder.setInlineClassUnderlyingType(type(representation.underlyingType))
builder.setInlineClassUnderlyingType(type(inlineClassRepresentation.underlyingType))
}
}
}
classDescriptor.multiFieldValueClassRepresentation?.let { multiFieldValueClassRepresentation ->
val namesToTypes = multiFieldValueClassRepresentation.underlyingPropertyNamesToTypes
builder.addAllMultiFieldValueClassUnderlyingName(namesToTypes.map { (name, _) -> getSimpleNameIndex(name) })
if (useTypeTable()) {
builder.addAllMultiFieldValueClassUnderlyingTypeId(namesToTypes.map { (_, kotlinType) -> typeId(kotlinType) })
} else {
builder.addAllMultiFieldValueClassUnderlyingType(namesToTypes.map { (_, kotlinType) -> type(kotlinType).build() })
}
}
if (versionRequirementTable == null) error("Version requirements must be serialized for classes: $classDescriptor")
builder.addAllVersionRequirement(versionRequirementTable.serializeVersionRequirements(classDescriptor))
@@ -513,7 +524,8 @@ class DescriptorSerializer private constructor(
val builder = ProtoBuf.TypeAlias.newBuilder()
val local = createChildSerializer(descriptor)
val flags = Flags.getTypeAliasFlags(hasAnnotations(descriptor), ProtoEnumFlags.descriptorVisibility(normalizeVisibility(descriptor)))
val flags =
Flags.getTypeAliasFlags(hasAnnotations(descriptor), ProtoEnumFlags.descriptorVisibility(normalizeVisibility(descriptor)))
if (flags != builder.flags) {
builder.flags = flags
}
compiler/testData/codegen/box/valueClasses/classFlattening.kt
Vendored
+1 -1
View File
@@ -18,4 +18,4 @@ value class GreaterMFVC(val x: SimpleMFVC, val y: IC, val z: SimpleMFVC)
fun gmfvc(ic: IC, x: GreaterMFVC, ic1: UInt) = smfvc(ic, x.x, 0U) + ic(x.y) + smfvc(IC(0U), x.z, ic1)
fun box() = "todo"
fun box() = "OK" // todo real test
compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.txt
Vendored
+1
View File
@@ -44,3 +44,4 @@ public inline object InlineObject {
public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int
public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String
}
compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.txt
Vendored
+1
View File
@@ -57,3 +57,4 @@ package kotlin {
}
}
}