From 41e230047383e4bec4cb15c1e891c89fa0f0e651 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 21 Oct 2013 21:12:54 +0400 Subject: [PATCH] Rename MemberMap and implement it via SlicedMap --- .../jetbrains/jet/codegen/ClassBuilder.java | 6 +- .../jet/codegen/FunctionCodegen.java | 7 +- .../codegen/ImplementationBodyCodegen.java | 2 +- .../jet/codegen/JavaSerializerExtension.java | 26 ++-- .../jet/codegen/JvmSerializationBindings.java | 111 ++++++++++++++ .../org/jetbrains/jet/codegen/MemberMap.java | 138 ------------------ .../jet/codegen/NamespaceCodegen.java | 13 +- .../jet/codegen/PropertyCodegen.java | 12 +- 8 files changed, 146 insertions(+), 169 deletions(-) create mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/JvmSerializationBindings.java delete mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/MemberMap.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBuilder.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBuilder.java index f36a4510650..89ff2a08d67 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBuilder.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBuilder.java @@ -27,7 +27,7 @@ public abstract class ClassBuilder { private String thisName; - private final MemberMap members = new MemberMap(); + private final JvmSerializationBindings serializationBindings = new JvmSerializationBindings(); public static class Concrete extends ClassBuilder { private final ClassVisitor v; @@ -76,8 +76,8 @@ public abstract class ClassBuilder { } @NotNull - public MemberMap getMemberMap() { - return members; + public JvmSerializationBindings getSerializationBindings() { + return serializationBindings; } @NotNull diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index ffeb94c43ba..9f41c5bb90e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -48,6 +48,7 @@ import java.util.*; import static org.jetbrains.asm4.Opcodes.*; import static org.jetbrains.jet.codegen.AsmUtil.*; import static org.jetbrains.jet.codegen.CodegenUtil.*; +import static org.jetbrains.jet.codegen.JvmSerializationBindings.*; import static org.jetbrains.jet.codegen.binding.CodegenBinding.asmTypeForAnonymousClass; import static org.jetbrains.jet.codegen.binding.CodegenBinding.isLocalNamedFun; import static org.jetbrains.jet.lang.resolve.BindingContextUtils.callableDescriptorToDeclaration; @@ -111,10 +112,10 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { if (owner instanceof NamespaceFacadeContext) { Type ownerType = ((NamespaceFacadeContext) owner).getDelegateToClassType(); - v.getMemberMap().recordImplClassNameForCallable(functionDescriptor, shortNameByAsmType(ownerType)); + v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, functionDescriptor, shortNameByAsmType(ownerType)); } else { - v.getMemberMap().recordMethodOfDescriptor(functionDescriptor, asmMethod); + v.getSerializationBindings().put(METHOD_FOR_FUNCTION, functionDescriptor, asmMethod); } AnnotationCodegen.forMethod(mv, typeMapper).genAnnotations(functionDescriptor); @@ -152,7 +153,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { if (kind == JvmMethodParameterKind.VALUE) { ValueParameterDescriptor parameter = iterator.next(); - v.getMemberMap().recordIndexForValueParameter(parameter, i); + v.getSerializationBindings().put(INDEX_FOR_VALUE_PARAMETER, parameter, i); AnnotationCodegen.forParameter(i, mv, typeMapper).genAnnotations(parameter); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index e2d70050bb6..19463c304e0 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -213,7 +213,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { @Override protected void generateKotlinAnnotation() { - DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(v.getMemberMap())); + DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(v.getSerializationBindings())); ProtoBuf.Class classProto = serializer.classProto(descriptor).build(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java b/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java index 77cac7989f5..7498912d972 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java @@ -31,11 +31,13 @@ import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Arrays; -public class JavaSerializerExtension extends SerializerExtension { - private final MemberMap memberMap; +import static org.jetbrains.jet.codegen.JvmSerializationBindings.*; - public JavaSerializerExtension(@NotNull MemberMap memberMap) { - this.memberMap = memberMap; +public class JavaSerializerExtension extends SerializerExtension { + private final JvmSerializationBindings bindings; + + public JavaSerializerExtension(@NotNull JvmSerializationBindings bindings) { + this.bindings = bindings; } @Override @@ -54,7 +56,7 @@ public class JavaSerializerExtension extends SerializerExtension { @NotNull ProtoBuf.Callable.ValueParameter.Builder proto, @NotNull NameTable nameTable ) { - Integer index = memberMap.getIndexForValueParameter(descriptor); + Integer index = bindings.get(INDEX_FOR_VALUE_PARAMETER, descriptor); if (index != null) { proto.setExtension(JavaProtoBuf.index, index); } @@ -66,7 +68,7 @@ public class JavaSerializerExtension extends SerializerExtension { @NotNull NameTable nameTable ) { if (callable instanceof FunctionDescriptor) { - Method method = memberMap.getMethodOfDescriptor((FunctionDescriptor) callable); + Method method = bindings.get(METHOD_FOR_FUNCTION, (FunctionDescriptor) callable); if (method != null) { proto.setExtension(JavaProtoBuf.methodSignature, new SignatureSerializer(nameTable).methodSignature(method)); } @@ -76,10 +78,10 @@ public class JavaSerializerExtension extends SerializerExtension { PropertyGetterDescriptor getter = property.getGetter(); PropertySetterDescriptor setter = property.getSetter(); - Method getterMethod = getter == null ? null : memberMap.getMethodOfDescriptor(getter); - Method setterMethod = setter == null ? null : memberMap.getMethodOfDescriptor(setter); + Method getterMethod = getter == null ? null : bindings.get(METHOD_FOR_FUNCTION, getter); + Method setterMethod = setter == null ? null : bindings.get(METHOD_FOR_FUNCTION, setter); - Pair field = memberMap.getFieldOfProperty(property); + Pair field = bindings.get(FIELD_FOR_PROPERTY, property); Type fieldType; String fieldName; boolean isStaticInOuter; @@ -87,14 +89,14 @@ public class JavaSerializerExtension extends SerializerExtension { if (field != null) { fieldType = field.first; fieldName = field.second; - isStaticInOuter = memberMap.isStaticFieldInOuterClass(property); + isStaticInOuter = bindings.get(STATIC_FIELD_IN_OUTER_CLASS, property); syntheticMethod = null; } else { fieldType = null; fieldName = null; isStaticInOuter = false; - syntheticMethod = memberMap.getSyntheticMethodOfProperty(property); + syntheticMethod = bindings.get(SYNTHETIC_METHOD_FOR_PROPERTY, property); } JavaProtoBuf.JavaPropertySignature signature = new SignatureSerializer(nameTable) @@ -108,7 +110,7 @@ public class JavaSerializerExtension extends SerializerExtension { @NotNull ProtoBuf.Callable.Builder proto, @NotNull NameTable nameTable ) { - String name = memberMap.getImplClassNameOfCallable(callable); + String name = bindings.get(IMPL_CLASS_NAME_FOR_CALLABLE, callable); if (name != null) { proto.setExtension(JavaProtoBuf.implClassName, nameTable.getSimpleNameIndex(Name.identifier(name))); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JvmSerializationBindings.java b/compiler/backend/src/org/jetbrains/jet/codegen/JvmSerializationBindings.java new file mode 100644 index 00000000000..fc00784209c --- /dev/null +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JvmSerializationBindings.java @@ -0,0 +1,111 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.codegen; + +import com.intellij.openapi.util.Pair; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.asm4.Type; +import org.jetbrains.asm4.commons.Method; +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.util.slicedmap.*; + +import java.util.Collection; +import java.util.Map; + +public final class JvmSerializationBindings { + public static final SerializationMappingSlice METHOD_FOR_FUNCTION = + SerializationMappingSlice.create(); + public static final SerializationMappingSlice> FIELD_FOR_PROPERTY = + SerializationMappingSlice.create(); + public static final SerializationMappingSlice SYNTHETIC_METHOD_FOR_PROPERTY = + SerializationMappingSlice.create(); + public static final SerializationMappingSlice IMPL_CLASS_NAME_FOR_CALLABLE = + SerializationMappingSlice.create(); + public static final SerializationMappingSetSlice STATIC_FIELD_IN_OUTER_CLASS = + SerializationMappingSetSlice.create(); + public static final SerializationMappingSlice INDEX_FOR_VALUE_PARAMETER = + SerializationMappingSlice.create(); + + private static final class SerializationMappingSlice extends BasicWritableSlice { + public SerializationMappingSlice() { + super(Slices.ONLY_REWRITE_TO_EQUAL, false); + } + + @NotNull + public static SerializationMappingSlice create() { + return new SerializationMappingSlice(); + } + } + + private static final class SerializationMappingSetSlice extends Slices.SetSlice { + public SerializationMappingSetSlice() { + super(Slices.ONLY_REWRITE_TO_EQUAL, false); + } + + @NotNull + public static SerializationMappingSetSlice create() { + return new SerializationMappingSetSlice(); + } + } + + static { + BasicWritableSlice.initSliceDebugNames(JvmSerializationBindings.class); + } + + private final MutableSlicedMap map; + + private JvmSerializationBindings(@NotNull MutableSlicedMap map) { + this.map = map; + } + + public JvmSerializationBindings() { + this(SlicedMapImpl.create()); + } + + @NotNull + public static JvmSerializationBindings union(@NotNull Collection bindings) { + MutableSlicedMap result = SlicedMapImpl.create(); + for (JvmSerializationBindings binding : bindings) { + for (Map.Entry, ?> entry : binding.map) { + SlicedMapKey key = entry.getKey(); + result.put((WritableSlice) key.getSlice(), key.getKey(), entry.getValue()); + } + } + return new JvmSerializationBindings(result); + } + + public void put(@NotNull SerializationMappingSlice slice, @NotNull K key, @NotNull V value) { + map.put(slice, key, value); + } + + public void put(@NotNull SerializationMappingSetSlice slice, @NotNull K key) { + map.put(slice, key, true); + } + + @Nullable + public V get(@NotNull SerializationMappingSlice slice, @NotNull K key) { + return map.get(slice, key); + } + + public boolean get(@NotNull SerializationMappingSetSlice slice, @NotNull K key) { + return Boolean.TRUE.equals(map.get(slice, key)); + } +} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/MemberMap.java b/compiler/backend/src/org/jetbrains/jet/codegen/MemberMap.java deleted file mode 100644 index 32e0edc3332..00000000000 --- a/compiler/backend/src/org/jetbrains/jet/codegen/MemberMap.java +++ /dev/null @@ -1,138 +0,0 @@ -/* - * Copyright 2010-2013 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.codegen; - -import com.intellij.openapi.util.Pair; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.asm4.Type; -import org.jetbrains.asm4.commons.Method; -import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; - -import java.util.*; - -public final class MemberMap { - private final Map methodForFunction = new HashMap(); - private final Map> fieldForProperty = new HashMap>(); - private final Map syntheticMethodForProperty = new HashMap(); - private final Map implClassNameForCallable = new HashMap(); - private final Set staticFieldInOuterClass = new HashSet(); - private final Map indexForValueParameter = new HashMap(); - - @NotNull - public static MemberMap union(@NotNull Collection maps) { - MemberMap result = new MemberMap(); - for (MemberMap map : maps) { - for (Map.Entry entry : map.methodForFunction.entrySet()) { - result.recordMethodOfDescriptor(entry.getKey(), entry.getValue()); - } - - for (Map.Entry> entry : map.fieldForProperty.entrySet()) { - result.recordFieldOfProperty(entry.getKey(), entry.getValue().first, entry.getValue().second); - } - - for (Map.Entry entry : map.syntheticMethodForProperty.entrySet()) { - result.recordSyntheticMethodOfProperty(entry.getKey(), entry.getValue()); - } - - for (Map.Entry entry : map.implClassNameForCallable.entrySet()) { - result.recordImplClassNameForCallable(entry.getKey(), entry.getValue()); - } - - for (PropertyDescriptor property : map.staticFieldInOuterClass) { - result.recordStaticFieldInOuterClass(property); - } - - for (Map.Entry entry : map.indexForValueParameter.entrySet()) { - result.recordIndexForValueParameter(entry.getKey(), entry.getValue()); - } - } - - return result; - } - - public void recordMethodOfDescriptor(@NotNull FunctionDescriptor descriptor, @NotNull Method method) { - Method old = methodForFunction.put(descriptor, method); - assert old == null : "Duplicate method for callable member: " + descriptor + "; " + old; - } - - public void recordFieldOfProperty(@NotNull PropertyDescriptor descriptor, @NotNull Type type, @NotNull String fieldName) { - Pair old = fieldForProperty.put(descriptor, Pair.create(type, fieldName)); - assert old == null : "Duplicate field for property: " + descriptor + "; " + old; - } - - public void recordSyntheticMethodOfProperty(@NotNull PropertyDescriptor descriptor, @NotNull Method method) { - Method old = syntheticMethodForProperty.put(descriptor, method); - assert old == null : "Duplicate synthetic method for property: " + descriptor + "; " + old; - } - - public void recordImplClassNameForCallable(@NotNull CallableMemberDescriptor descriptor, @NotNull String name) { - String old = implClassNameForCallable.put(descriptor, name); - assert old == null : "Duplicate src class name for callable: " + descriptor + "; " + old; - } - - public void recordStaticFieldInOuterClass(@NotNull PropertyDescriptor property) { - boolean added = staticFieldInOuterClass.add(property); - assert added : "Duplicate static field in outer class: " + property; - } - - public void recordIndexForValueParameter(@NotNull ValueParameterDescriptor descriptor, int index) { - Integer old = indexForValueParameter.put(descriptor, index); - assert old == null || old == index : "Duplicate index for value parameter: " + descriptor; - } - - @Nullable - public Method getMethodOfDescriptor(@NotNull FunctionDescriptor descriptor) { - return methodForFunction.get(descriptor); - } - - @Nullable - public Pair getFieldOfProperty(@NotNull PropertyDescriptor descriptor) { - return fieldForProperty.get(descriptor); - } - - @Nullable - public Method getSyntheticMethodOfProperty(@NotNull PropertyDescriptor descriptor) { - return syntheticMethodForProperty.get(descriptor); - } - - @Nullable - public String getImplClassNameOfCallable(@NotNull CallableMemberDescriptor descriptor) { - return implClassNameForCallable.get(descriptor); - } - - public boolean isStaticFieldInOuterClass(@NotNull PropertyDescriptor property) { - return staticFieldInOuterClass.contains(property); - } - - @Nullable - public Integer getIndexForValueParameter(@NotNull ValueParameterDescriptor descriptor) { - return indexForValueParameter.get(descriptor); - } - - @Override - public String toString() { - return "Functions: " + methodForFunction.size() + - ", fields: " + fieldForProperty.size() + - ", synthetic methods: " + syntheticMethodForProperty.size() + - ", impl class names: " + implClassNameForCallable.size() + - ", value parameters: " + indexForValueParameter.size(); - } -} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java index 3ba136af3e6..255bdbf87ce 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java @@ -102,17 +102,17 @@ public class NamespaceCodegen extends MemberCodegen { } public void generate(@NotNull CompilationErrorHandler errorHandler) { - List namespaceMembers = new ArrayList(files.size() + 1); + List bindings = new ArrayList(files.size() + 1); boolean shouldGeneratePackageClass = shouldGenerateNSClass(files); if (shouldGeneratePackageClass) { - namespaceMembers.add(v.getClassBuilder().getMemberMap()); + bindings.add(v.getClassBuilder().getSerializationBindings()); } for (JetFile file : files) { try { ClassBuilder builder = generate(file); if (builder != null) { - namespaceMembers.add(builder.getMemberMap()); + bindings.add(builder.getSerializationBindings()); } } catch (ProcessCanceledException e) { @@ -130,14 +130,14 @@ public class NamespaceCodegen extends MemberCodegen { } if (shouldGeneratePackageClass) { - writeKotlinPackageAnnotationIfNeeded(MemberMap.union(namespaceMembers)); + writeKotlinPackageAnnotationIfNeeded(JvmSerializationBindings.union(bindings)); } assert v.isActivated() == shouldGeneratePackageClass : "Different algorithms for generating namespace class and for heuristics for: " + name.asString(); } - private void writeKotlinPackageAnnotationIfNeeded(@NotNull MemberMap members) { + private void writeKotlinPackageAnnotationIfNeeded(@NotNull JvmSerializationBindings bindings) { if (state.getClassBuilderMode() != ClassBuilderMode.FULL) { return; } @@ -146,7 +146,7 @@ public class NamespaceCodegen extends MemberCodegen { if (file.isScript()) return; } - DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(members)); + DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(bindings)); ProtoBuf.Package packageProto = serializer.packageProto(descriptor).build(); if (packageProto.getMemberCount() == 0) return; @@ -164,7 +164,6 @@ public class NamespaceCodegen extends MemberCodegen { av.visitEnd(); } - @Nullable private ClassBuilder generate(@NotNull JetFile file) { boolean generateSrcClass = false; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index beb84b15188..96c2d21ee49 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.codegen; +import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -48,6 +49,7 @@ import static org.jetbrains.asm4.Opcodes.*; import static org.jetbrains.jet.codegen.AsmUtil.*; import static org.jetbrains.jet.codegen.CodegenUtil.getParentBodyCodegen; import static org.jetbrains.jet.codegen.CodegenUtil.isInterface; +import static org.jetbrains.jet.codegen.JvmSerializationBindings.*; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isTrait; import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; @@ -92,7 +94,7 @@ public class PropertyCodegen extends GenerationStateAware { if (context instanceof NamespaceFacadeContext) { Type ownerType = ((NamespaceFacadeContext) context).getDelegateToClassType(); - v.getMemberMap().recordImplClassNameForCallable(propertyDescriptor, shortNameByAsmType(ownerType)); + v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, propertyDescriptor, shortNameByAsmType(ownerType)); } else if (!generateBackingField(p, propertyDescriptor)) { generateSyntheticMethodIfNeeded(propertyDescriptor); @@ -169,11 +171,11 @@ public class PropertyCodegen extends GenerationStateAware { } else { Type tImplType = typeMapper.mapTraitImpl((ClassDescriptor) context.getContextDescriptor()); - v.getMemberMap().recordImplClassNameForCallable(descriptor, shortNameByAsmType(tImplType)); + v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, descriptor, shortNameByAsmType(tImplType)); } if (kind != OwnerKind.TRAIT_IMPL) { - v.getMemberMap().recordSyntheticMethodOfProperty(descriptor, method); + v.getSerializationBindings().put(SYNTHETIC_METHOD_FOR_PROPERTY, descriptor, method); } } @@ -202,7 +204,7 @@ public class PropertyCodegen extends GenerationStateAware { ImplementationBodyCodegen codegen = getParentBodyCodegen(classBodyCodegen); builder = codegen.v; backingFieldContext = codegen.context; - v.getMemberMap().recordStaticFieldInOuterClass(propertyDescriptor); + v.getSerializationBindings().put(STATIC_FIELD_IN_OUTER_CLASS, propertyDescriptor); } else { if (kind != OwnerKind.NAMESPACE || isDelegate) { modifiers |= ACC_PRIVATE; @@ -216,7 +218,7 @@ public class PropertyCodegen extends GenerationStateAware { String name = backingFieldContext.getFieldName(propertyDescriptor, isDelegate); - v.getMemberMap().recordFieldOfProperty(propertyDescriptor, type, name); + v.getSerializationBindings().put(FIELD_FOR_PROPERTY, propertyDescriptor, Pair.create(type, name)); return builder.newField(element, modifiers, name, type.getDescriptor(), typeMapper.mapFieldSignature(jetType), defaultValue);