From 83501c37226da0d3243b6d78fca3b6ee0f0a478f Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 27 Jun 2013 22:49:08 +0400 Subject: [PATCH] KotlinInfo now has only one parameter data Name table is now also stored in data, before the serialized class. ClassData is now public, since it's used in plenty of places as a holder of deserialized protobuf classes. --- .../codegen/ImplementationBodyCodegen.java | 26 ++++++++++--- .../jet/lang/resolve/java/JvmStdlibNames.java | 2 + .../java/resolver/JavaAnnotationResolver.java | 7 +--- .../serialization/AbstractClassResolver.java | 20 ---------- .../descriptors/serialization/ClassData.java | 39 +++++++++++++++++++ .../serialization/ClassSerializationUtil.java | 16 ++++++++ .../WriteSerializedInfoTest.java | 13 +++---- runtime/src/jet/KotlinInfo.java | 2 - 8 files changed, 85 insertions(+), 40 deletions(-) create mode 100644 compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassData.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 6cb2635ab3a..d213bea670f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -61,8 +61,10 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; +import org.jetbrains.jet.utils.ExceptionUtils; import java.io.ByteArrayOutputStream; +import java.io.IOException; import java.util.*; import static org.jetbrains.asm4.Opcodes.*; @@ -219,21 +221,35 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } private void writeKotlinInfo() { - final AnnotationVisitor av = v.getVisitor().visitAnnotation("Ljet/KotlinInfo;", true); + AnnotationVisitor av = v.getVisitor().visitAnnotation(JvmStdlibNames.KOTLIN_INFO_CLASS.getDescriptor(), true); DescriptorSerializer serializer = new DescriptorSerializer(DescriptorNamer.DEFAULT); + final ByteArrayOutputStream classStream = new ByteArrayOutputStream(); + ClassSerializationUtil.serializeClass(descriptor, constantSerializer(serializer), new ClassSerializationUtil.Sink() { @Override public void writeClass(@NotNull ClassDescriptor classDescriptor, @NotNull ProtoBuf.Class classProto) { if (classDescriptor == descriptor) { - av.visit("data", classProto.toByteArray()); + try { + classProto.writeTo(classStream); + } + catch (IOException e) { + throw ExceptionUtils.rethrow(e); + } } } }); - ByteArrayOutputStream nameTable = new ByteArrayOutputStream(); - NameSerializationUtil.serializeNameTable(nameTable, serializer.getNameTable()); - av.visit("nameTable", nameTable.toByteArray()); + ByteArrayOutputStream out = new ByteArrayOutputStream(); + NameSerializationUtil.serializeNameTable(out, serializer.getNameTable()); + try { + out.write(classStream.toByteArray()); + } + catch (IOException e) { + throw ExceptionUtils.rethrow(e); + } + + av.visit("data", out.toByteArray()); av.visitEnd(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java index b4bab103ef0..98406a29f9f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.lang.resolve.java; +import jet.KotlinInfo; import jet.runtime.typeinfo.JetConstructor; public class JvmStdlibNames { @@ -68,6 +69,7 @@ public class JvmStdlibNames { */ public static final String JET_CONSTRUCTOR_HIDDEN_FIELD = "hidden"; + public static final JvmClassName KOTLIN_INFO_CLASS = JvmClassName.byFqNameWithoutInnerClasses(KotlinInfo.class.getCanonicalName()); public static final JvmClassName JET_CLASS = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.JetClass"); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java index 8b785ba5c22..e13dc885a03 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java @@ -25,10 +25,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; -import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap; -import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -86,7 +83,7 @@ public final class JavaAnnotationResolver { // Don't process internal jet annotations and jetbrains NotNull annotations if (qname.startsWith("jet.runtime.typeinfo.") || qname.equals(JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) - || qname.equals("jet.KotlinInfo") + || qname.equals(JvmStdlibNames.KOTLIN_INFO_CLASS.getFqName().asString()) ) { return null; } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java index fdd9be53fec..b9bfe56d753 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractClassResolver.java @@ -97,24 +97,4 @@ public abstract class AbstractClassResolver implements ClassResolver { protected abstract Name getClassObjectName(@NotNull ClassDescriptor outerClass); protected abstract void classDescriptorCreated(@NotNull ClassDescriptor classDescriptor); - - protected static class ClassData { - private final NameResolver nameResolver; - private final ProtoBuf.Class classProto; - - public ClassData(@NotNull NameResolver nameResolver, @NotNull ProtoBuf.Class classProto) { - this.nameResolver = nameResolver; - this.classProto = classProto; - } - - @NotNull - public NameResolver getNameResolver() { - return nameResolver; - } - - @NotNull - public ProtoBuf.Class getClassProto() { - return classProto; - } - } } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassData.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassData.java new file mode 100644 index 00000000000..e370b98127a --- /dev/null +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassData.java @@ -0,0 +1,39 @@ +/* + * 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.descriptors.serialization; + +import org.jetbrains.annotations.NotNull; + +public class ClassData { + private final NameResolver nameResolver; + private final ProtoBuf.Class classProto; + + public ClassData(@NotNull NameResolver nameResolver, @NotNull ProtoBuf.Class classProto) { + this.nameResolver = nameResolver; + this.classProto = classProto; + } + + @NotNull + public NameResolver getNameResolver() { + return nameResolver; + } + + @NotNull + public ProtoBuf.Class getClassProto() { + return classProto; + } +} diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java index 6f9ab18c970..258392a4ba9 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java @@ -23,7 +23,10 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; +import org.jetbrains.jet.utils.ExceptionUtils; +import java.io.ByteArrayInputStream; +import java.io.IOException; import java.util.Collection; public class ClassSerializationUtil { @@ -83,6 +86,19 @@ public class ClassSerializationUtil { } } + @NotNull + public static ClassData readClassDataFrom(@NotNull byte[] bytes) { + try { + ByteArrayInputStream in = new ByteArrayInputStream(bytes); + NameResolver nameResolver = NameSerializationUtil.deserializeNameResolver(in); + ProtoBuf.Class classProto = ProtoBuf.Class.parseFrom(in); + return new ClassData(nameResolver, classProto); + } + catch (IOException e) { + throw ExceptionUtils.rethrow(e); + } + } + @NotNull public static ClassId getClassId(@NotNull ClassDescriptor classDescriptor, @NotNull DescriptorNamer namer) { DeclarationDescriptor containingDeclaration = classDescriptor.getContainingDeclaration(); diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/WriteSerializedInfoTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/WriteSerializedInfoTest.java index f5bbac3e51b..cd8538f8ebe 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/WriteSerializedInfoTest.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/WriteSerializedInfoTest.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.descriptors.serialization; -import com.google.protobuf.InvalidProtocolBufferException; import jet.KotlinInfo; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -32,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; -import java.io.ByteArrayInputStream; +import java.io.IOException; public class WriteSerializedInfoTest extends CodegenTestCase { public static final FqName NAMESPACE_NAME = new FqName("test"); @@ -64,15 +63,13 @@ public class WriteSerializedInfoTest extends CodegenTestCase { } private static class KotlinInfoBasedClassResolver extends AbstractClassResolver { - private final NameResolver nameResolver; - private final ProtoBuf.Class classProto; + private final ClassData classData; private final NamespaceDescriptorImpl namespace; - public KotlinInfoBasedClassResolver(@NotNull KotlinInfo kotlinInfo) throws InvalidProtocolBufferException { + public KotlinInfoBasedClassResolver(@NotNull KotlinInfo kotlinInfo) throws IOException { super(new LockBasedStorageManager(), AnnotationDeserializer.UNSUPPORTED); - this.nameResolver = NameSerializationUtil.deserializeNameResolver(new ByteArrayInputStream(kotlinInfo.nameTable())); - this.classProto = ProtoBuf.Class.parseFrom(kotlinInfo.data()); + this.classData = ClassSerializationUtil.readClassDataFrom(kotlinInfo.data()); this.namespace = JetTestUtils.createTestNamespace(NAMESPACE_NAME.asString()); } @@ -81,7 +78,7 @@ public class WriteSerializedInfoTest extends CodegenTestCase { protected ClassData getClassData(@NotNull ClassId classId) { assert classId.getPackageFqName().equals(NAMESPACE_NAME) && classId.getRelativeClassName().equals(CLASS_NAME) : "Unsupported classId: " + classId; - return new ClassData(nameResolver, classProto); + return classData; } @NotNull diff --git a/runtime/src/jet/KotlinInfo.java b/runtime/src/jet/KotlinInfo.java index cbbd5bd8dde..3319dcdeb69 100644 --- a/runtime/src/jet/KotlinInfo.java +++ b/runtime/src/jet/KotlinInfo.java @@ -22,6 +22,4 @@ import java.lang.annotation.RetentionPolicy; @Retention(RetentionPolicy.RUNTIME) public @interface KotlinInfo { byte[] data(); - - byte[] nameTable(); }