proto serialization

compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java

@@ -287,11 +287,12 @@ public class PackageCodegen {
         ProtoBuf.Package packageProto = serializer.packageProto(packageFragments, new Function1<DeclarationDescriptor, Boolean>() {
             @Override
             public Boolean invoke(DeclarationDescriptor descriptor) {
-                return !(descriptor instanceof CallableMemberDescriptor && relevantCallables.contains(descriptor));
+//                return !(descriptor instanceof CallableMemberDescriptor && relevantCallables.contains(descriptor));
+                return true;
             }
         }).build();
 
-        if (packageProto.getMemberCount() == 0) return;
+        //if (packageProto.getMemberCount() == 0) return;
 
         StringTable strings = serializer.getStringTable();
         NameResolver nameResolver = new NameResolver(strings.serializeSimpleNames(), strings.serializeQualifiedNames());

compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java

@@ -16,18 +16,35 @@
 
 package org.jetbrains.kotlin.codegen;
 
+import com.google.common.collect.Lists;
 import com.intellij.util.ArrayUtil;
 import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.codegen.context.FieldOwnerContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
+import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
+import org.jetbrains.kotlin.descriptors.VariableDescriptor;
+import org.jetbrains.kotlin.load.java.JvmAbi;
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.psi.JetDeclaration;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.psi.JetNamedFunction;
 import org.jetbrains.kotlin.psi.JetProperty;
+import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.serialization.*;
+import org.jetbrains.kotlin.serialization.deserialization.NameResolver;
+import org.jetbrains.kotlin.serialization.jvm.BitEncoding;
+import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
 import org.jetbrains.org.objectweb.asm.Type;
 
-import static org.jetbrains.kotlin.codegen.AsmUtil.writeKotlinSyntheticClassAnnotation;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.ABI_VERSION_FIELD_NAME;
 import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.KotlinSyntheticClass;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
@@ -79,6 +96,56 @@ public class PackagePartCodegen extends MemberCodegen<JetFile> {
 
     @Override
     protected void generateKotlinAnnotation() {
-        writeKotlinSyntheticClassAnnotation(v, KotlinSyntheticClass.Kind.PACKAGE_PART);
+        if (state.getClassBuilderMode() != ClassBuilderMode.FULL) {
+            return;
+        }
+
+        List<DeclarationDescriptor> members = new ArrayList<DeclarationDescriptor>();
+        for (JetDeclaration declaration : element.getDeclarations()) {
+            if (declaration instanceof JetNamedFunction) {
+                SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration);
+                members.add(functionDescriptor);
+            } else if (declaration instanceof JetProperty) {
+                VariableDescriptor property = bindingContext.get(BindingContext.VARIABLE, declaration);
+                members.add(property);
+            }
+        }
+
+        AnnotationVisitor av = v.newAnnotation(Type.getObjectType(KotlinSyntheticClass.CLASS_NAME.getInternalName()).getDescriptor(), true);
+        av.visit(ABI_VERSION_FIELD_NAME, JvmAbi.VERSION);
+        av.visitEnum(
+                JvmAnnotationNames.KIND_FIELD_NAME,
+                Type.getObjectType(KotlinSyntheticClass.KIND_INTERNAL_NAME).getDescriptor(),
+                KotlinSyntheticClass.Kind.PACKAGE_PART.toString()
+        );
+
+        JvmSerializationBindings bindings = v.getSerializationBindings();
+
+        DescriptorSerializer serializer = DescriptorSerializer.createTopLevel(new JvmSerializerExtension(bindings, state.getTypeMapper()));
+        Collection<PackageFragmentDescriptor> packageFragments = Lists.newArrayList();
+        //ContainerUtil.addIfNotNull(packageFragments, packageFragment);
+        //ContainerUtil.addIfNotNull(packageFragments, compiledPackageFragment);
+
+        ProtoBuf.Package packageProto = serializer.packagePartProto(members, new Function1<DeclarationDescriptor, Boolean>() {
+            @Override
+            public Boolean invoke(DeclarationDescriptor descriptor) {
+                //return !(descriptor instanceof CallableMemberDescriptor && relevantCallables.contains(descriptor));
+                return false;
+            }
+        }).build();
+
+        if (packageProto.getMemberCount() == 0) return;
+
+        StringTable strings = serializer.getStringTable();
+        NameResolver nameResolver = new NameResolver(strings.serializeSimpleNames(), strings.serializeQualifiedNames());
+        PackageData data = new PackageData(nameResolver, packageProto);
+
+
+        AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME);
+        for (String string : BitEncoding.encodeBytes(SerializationUtil.serializePackageData(data))) {
+            array.visit(null, string);
+        }
+        array.visitEnd();
+        av.visitEnd();
     }
 }

compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java

@@ -432,6 +432,21 @@ public class DescriptorSerializer {
         return builder;
     }
 
+    @NotNull
+    public ProtoBuf.Package.Builder packagePartProto(@NotNull Collection<DeclarationDescriptor> members, @Nullable Function1<DeclarationDescriptor, Boolean> skip) {
+        ProtoBuf.Package.Builder builder = ProtoBuf.Package.newBuilder();
+
+        for (DeclarationDescriptor declaration : sort(members)) {
+            if (skip != null && skip.invoke(declaration)) continue;
+
+            if (declaration instanceof PropertyDescriptor || declaration instanceof FunctionDescriptor) {
+                builder.addMember(callableProto((CallableMemberDescriptor) declaration));
+            }
+        }
+
+        return builder;
+    }
+
     @NotNull
     private static ProtoBuf.Type.Argument.Projection projection(@NotNull Variance projectionKind) {
         switch (projectionKind) {