KT-12877: add JsNonModule with support on front-end

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.js.analyze
 
+import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.context.ContextForNewModule
@@ -25,6 +26,7 @@ import org.jetbrains.kotlin.frontend.js.di.createTopDownAnalyzerForJs
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
 import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.js.resolve.MODULE_KIND
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
@@ -39,7 +41,9 @@ object TopDownAnalyzerFacadeForJS {
                 config.moduleDescriptors.map { it.data } +
                 listOf(JsPlatform.builtIns.builtInsModule)
         )
-        return analyzeFilesWithGivenTrace(files, BindingTraceContext(), context, config)
+        val trace = BindingTraceContext()
+        trace.record(MODULE_KIND, context.module, config.moduleKind)
+        return analyzeFilesWithGivenTrace(files, trace, context, config)
     }
 
     @JvmStatic

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt

@@ -37,7 +37,7 @@ object JsPlatformConfigurator : PlatformConfigurator(
                 JsNameChecker, JsModuleChecker,
                 PlatformImplDeclarationChecker()
         ),
-        additionalCallCheckers = listOf(ReifiedTypeParameterSubstitutionChecker()),
+        additionalCallCheckers = listOf(ReifiedTypeParameterSubstitutionChecker(), JsModuleCallChecker),
         additionalTypeCheckers = listOf(),
         additionalClassifierUsageCheckers = listOf(),
         additionalAnnotationCheckers = listOf(),

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/bindingContextSlicesJs.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.js.resolve
+
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.serialization.js.ModuleKind
+import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice
+import org.jetbrains.kotlin.util.slicedMap.RewritePolicy
+
+@JvmField val MODULE_KIND = BasicWritableSlice<ModuleDescriptor, ModuleKind>(RewritePolicy.DO_NOTHING)

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/DefaultErrorMessagesJs.kt

@@ -50,6 +50,10 @@ private val DIAGNOSTIC_FACTORY_TO_RENDERER by lazy {
         put(ErrorsJs.JS_NAME_PROHIBITED_FOR_NAMED_NATIVE, "@JsName is prohibited for @native declaration with explicit name")
         put(ErrorsJs.JS_MODULE_PROHIBITED_ON_VAR, "@JsModule annotation prohibited for 'var' declarations. Use 'val' instead.")
         put(ErrorsJs.JS_MODULE_PROHIBITED_ON_NON_NATIVE, "@JsModule annotation prohibited for non-@native declarations.")
+        put(ErrorsJs.CALL_TO_JS_MODULE_WITHOUT_MODULE_SYSTEM, "Can't access declaration marked with @JsModule annotation " +
+                                                              "from non-modular project")
+        put(ErrorsJs.CALL_TO_JS_NON_MODULE_WITH_MODULE_SYSTEM, "Can't access declaration marked with @JsNonModule annotation " +
+                                                              "from modular project")
         put(ErrorsJs.CANNOT_CHECK_FOR_NATIVE_INTERFACE, "Cannot check for native interface: {0}", RENDER_TYPE)
         put(ErrorsJs.UNCHECKED_CAST_TO_NATIVE_INTERFACE, "Unchecked cast to native interface: {0} to {1}", RENDER_TYPE, RENDER_TYPE)
         put(ErrorsJs.NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT, "Cannot pass native interface {0} for reified type parameter", RENDER_TYPE)

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/ErrorsJs.java

@@ -54,6 +54,8 @@ public interface ErrorsJs {
     DiagnosticFactory0<PsiElement> JS_NAME_PROHIBITED_FOR_NAMED_NATIVE = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtElement> JS_MODULE_PROHIBITED_ON_VAR = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
     DiagnosticFactory0<KtElement> JS_MODULE_PROHIBITED_ON_NON_NATIVE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
+    DiagnosticFactory0<PsiElement> CALL_TO_JS_MODULE_WITHOUT_MODULE_SYSTEM = DiagnosticFactory0.create(ERROR, DEFAULT);
+    DiagnosticFactory0<PsiElement> CALL_TO_JS_NON_MODULE_WITH_MODULE_SYSTEM = DiagnosticFactory0.create(ERROR, DEFAULT);
     DiagnosticFactory1<PsiElement, KotlinType> CANNOT_CHECK_FOR_NATIVE_INTERFACE = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory2<PsiElement, KotlinType, KotlinType> UNCHECKED_CAST_TO_NATIVE_INTERFACE = DiagnosticFactory2.create(WARNING);
     DiagnosticFactory1<PsiElement, KotlinType> NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT = DiagnosticFactory1.create(ERROR);

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsModuleCallChecker.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.js.resolve.diagnostics
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.jetbrains.kotlin.js.resolve.MODULE_KIND
+import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
+import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.resolve.scopes.receivers.ClassValueReceiver
+import org.jetbrains.kotlin.serialization.js.ModuleKind
+
+object JsModuleCallChecker : CallChecker {
+    override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
+        val bindingContext = context.trace.bindingContext
+        val containingDescriptor = context.scope.ownerDescriptor
+        val module = DescriptorUtils.getContainingModule(containingDescriptor)
+        val moduleKind = bindingContext[MODULE_KIND, module] ?: return
+
+        val callee = findRoot(extractModuleCallee(resolvedCall) ?: return)
+        if (!AnnotationsUtils.isNativeObject(callee)) return
+
+        val callToModule = AnnotationsUtils.getModuleName(callee) != null ||
+                           AnnotationsUtils.getFileModuleName(bindingContext, callee) != null
+        val callToNonModule = AnnotationsUtils.isNonModule(callee) || AnnotationsUtils.isFromNonModuleFile(bindingContext, callee)
+
+        if (moduleKind == ModuleKind.PLAIN || moduleKind == ModuleKind.UMD) {
+            if (!callToNonModule && callToModule) {
+                context.trace.report(ErrorsJs.CALL_TO_JS_MODULE_WITHOUT_MODULE_SYSTEM.on(reportOn))
+            }
+        }
+        if (moduleKind != ModuleKind.PLAIN) {
+            if (!callToModule && callToNonModule) {
+                context.trace.report(ErrorsJs.CALL_TO_JS_NON_MODULE_WITH_MODULE_SYSTEM.on(reportOn))
+            }
+        }
+    }
+
+    private fun extractModuleCallee(call: ResolvedCall<*>): DeclarationDescriptor? {
+        val callee = call.resultingDescriptor
+        if (DescriptorUtils.isTopLevelDeclaration(callee)) return callee
+
+        val receiver = call.dispatchReceiver ?: return callee
+        if (receiver is ClassValueReceiver) return receiver.classQualifier.descriptor
+
+        return null
+    }
+
+    private fun findRoot(callee: DeclarationDescriptor) =
+            generateSequence(callee) { it.containingDeclaration }
+            .takeWhile { it !is PackageFragmentDescriptor }
+            .last()
+}

js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java

@@ -41,6 +41,7 @@ import java.util.List;
 public final class AnnotationsUtils {
     private static final String JS_NAME = "kotlin.js.JsName";
     private static final FqName JS_MODULE_ANNOTATION = new FqName("kotlin.js.JsModule");
+    private static final FqName JS_NON_MODULE_ANNOTATION = new FqName("kotlin.js.JsNonModule");
 
     private AnnotationsUtils() {
     }
@@ -203,6 +204,24 @@ public final class AnnotationsUtils {
         return null;
     }
 
+    public static boolean isNonModule(@NotNull DeclarationDescriptor declaration) {
+        return declaration.getAnnotations().findAnnotation(JS_NON_MODULE_ANNOTATION) != null;
+    }
+
+    public static boolean isFromNonModuleFile(@NotNull BindingContext bindingContext, @NotNull DeclarationDescriptor declaration) {
+        for (AnnotationDescriptor annotation : getContainingFileAnnotations(bindingContext, declaration)) {
+            DeclarationDescriptor annotationType = annotation.getType().getConstructor().getDeclarationDescriptor();
+            if (annotationType == null) continue;
+
+            FqNameUnsafe fqName = DescriptorUtils.getFqName(annotation.getType().getConstructor().getDeclarationDescriptor());
+            if (fqName.equals(JS_NON_MODULE_ANNOTATION.toUnsafe())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     @NotNull
     private static String extractJsModuleName(@NotNull AnnotationDescriptor annotation) {
         ConstantValue<?> importValue = annotation.getAllValueArguments().values().iterator().next();
@@ -225,7 +244,9 @@ public final class AnnotationsUtils {
             List<AnnotationDescriptor> annotations = new ArrayList<AnnotationDescriptor>();
             for (KtAnnotationEntry psiAnnotation : kotlinFile.getAnnotationEntries()) {
                 AnnotationDescriptor annotation = bindingContext.get(BindingContext.ANNOTATION, psiAnnotation);
-                annotations.add(annotation);
+                if (annotation != null) {
+                    annotations.add(annotation);
+                }
             }
             return annotations;
         }

js/js.libraries/src/core/annotations.kt

@@ -52,4 +52,8 @@ annotation class JsName(val name: String)
 
 @Retention(AnnotationRetention.BINARY)
 @Target(CLASS, PROPERTY, FUNCTION, FILE)
-annotation class JsModule(val import: String)
+annotation class JsModule(val import: String)
+
+@Retention(AnnotationRetention.BINARY)
+@Target(CLASS, PROPERTY, FUNCTION, FILE)
+annotation class JsNonModule

js/js.serializer/src/js.proto

@@ -26,6 +26,10 @@ message File {
   repeated Annotation annotation = 2;
 }
 
+message Files {
+  repeated File file = 1;
+}
+
 extend Class {
   repeated Annotation class_annotation = 130;
   optional int32 class_containing_file_id = 135;

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/JsProtoBuf.java

@@ -602,6 +602,499 @@ public final class JsProtoBuf {
     // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.js.File)
   }
 
+  public interface FilesOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.serialization.js.Files)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    java.util.List<org.jetbrains.kotlin.serialization.js.JsProtoBuf.File> 
+        getFileList();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    org.jetbrains.kotlin.serialization.js.JsProtoBuf.File getFile(int index);
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    int getFileCount();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.serialization.js.Files}
+   */
+  public static final class Files extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.serialization.js.Files)
+      FilesOrBuilder {
+    // Use Files.newBuilder() to construct.
+    private Files(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Files(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Files defaultInstance;
+    public static Files getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Files getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Files(
+        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);
+      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 10: {
+              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+                file_ = new java.util.ArrayList<org.jetbrains.kotlin.serialization.js.JsProtoBuf.File>();
+                mutable_bitField0_ |= 0x00000001;
+              }
+              file_.add(input.readMessage(org.jetbrains.kotlin.serialization.js.JsProtoBuf.File.PARSER, extensionRegistry));
+              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)) {
+          file_ = java.util.Collections.unmodifiableList(file_);
+        }
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Files> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Files>() {
+      public Files parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Files(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Files> getParserForType() {
+      return PARSER;
+    }
+
+    public static final int FILE_FIELD_NUMBER = 1;
+    private java.util.List<org.jetbrains.kotlin.serialization.js.JsProtoBuf.File> file_;
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    public java.util.List<org.jetbrains.kotlin.serialization.js.JsProtoBuf.File> getFileList() {
+      return file_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    public java.util.List<? extends org.jetbrains.kotlin.serialization.js.JsProtoBuf.FileOrBuilder> 
+        getFileOrBuilderList() {
+      return file_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    public int getFileCount() {
+      return file_.size();
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    public org.jetbrains.kotlin.serialization.js.JsProtoBuf.File getFile(int index) {
+      return file_.get(index);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+     */
+    public org.jetbrains.kotlin.serialization.js.JsProtoBuf.FileOrBuilder getFileOrBuilder(
+        int index) {
+      return file_.get(index);
+    }
+
+    private void initFields() {
+      file_ = 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;
+
+      for (int i = 0; i < getFileCount(); i++) {
+        if (!getFile(i).isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      for (int i = 0; i < file_.size(); i++) {
+        output.writeMessage(1, file_.get(i));
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      for (int i = 0; i < file_.size(); i++) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(1, file_.get(i));
+      }
+      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.serialization.js.JsProtoBuf.Files parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files 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.serialization.js.JsProtoBuf.Files parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files 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.serialization.js.JsProtoBuf.Files parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files 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.serialization.js.JsProtoBuf.Files parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files 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.serialization.js.JsProtoBuf.Files parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files 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.serialization.js.JsProtoBuf.Files prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.serialization.js.Files}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.serialization.js.Files)
+        org.jetbrains.kotlin.serialization.js.JsProtoBuf.FilesOrBuilder {
+      // Construct using org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        file_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files build() {
+        org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files buildPartial() {
+        org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files result = new org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files(this);
+        int from_bitField0_ = bitField0_;
+        if (((bitField0_ & 0x00000001) == 0x00000001)) {
+          file_ = java.util.Collections.unmodifiableList(file_);
+          bitField0_ = (bitField0_ & ~0x00000001);
+        }
+        result.file_ = file_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files other) {
+        if (other == org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files.getDefaultInstance()) return this;
+        if (!other.file_.isEmpty()) {
+          if (file_.isEmpty()) {
+            file_ = other.file_;
+            bitField0_ = (bitField0_ & ~0x00000001);
+          } else {
+            ensureFileIsMutable();
+            file_.addAll(other.file_);
+          }
+          
+        }
+        setUnknownFields(
+            getUnknownFields().concat(other.unknownFields));
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        for (int i = 0; i < getFileCount(); i++) {
+          if (!getFile(i).isInitialized()) {
+            
+            return false;
+          }
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.serialization.js.JsProtoBuf.Files) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private java.util.List<org.jetbrains.kotlin.serialization.js.JsProtoBuf.File> file_ =
+        java.util.Collections.emptyList();
+      private void ensureFileIsMutable() {
+        if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+          file_ = new java.util.ArrayList<org.jetbrains.kotlin.serialization.js.JsProtoBuf.File>(file_);
+          bitField0_ |= 0x00000001;
+         }
+      }
+
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public java.util.List<org.jetbrains.kotlin.serialization.js.JsProtoBuf.File> getFileList() {
+        return java.util.Collections.unmodifiableList(file_);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public int getFileCount() {
+        return file_.size();
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public org.jetbrains.kotlin.serialization.js.JsProtoBuf.File getFile(int index) {
+        return file_.get(index);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder setFile(
+          int index, org.jetbrains.kotlin.serialization.js.JsProtoBuf.File value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureFileIsMutable();
+        file_.set(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder setFile(
+          int index, org.jetbrains.kotlin.serialization.js.JsProtoBuf.File.Builder builderForValue) {
+        ensureFileIsMutable();
+        file_.set(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder addFile(org.jetbrains.kotlin.serialization.js.JsProtoBuf.File value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureFileIsMutable();
+        file_.add(value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder addFile(
+          int index, org.jetbrains.kotlin.serialization.js.JsProtoBuf.File value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureFileIsMutable();
+        file_.add(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder addFile(
+          org.jetbrains.kotlin.serialization.js.JsProtoBuf.File.Builder builderForValue) {
+        ensureFileIsMutable();
+        file_.add(builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder addFile(
+          int index, org.jetbrains.kotlin.serialization.js.JsProtoBuf.File.Builder builderForValue) {
+        ensureFileIsMutable();
+        file_.add(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder addAllFile(
+          java.lang.Iterable<? extends org.jetbrains.kotlin.serialization.js.JsProtoBuf.File> values) {
+        ensureFileIsMutable();
+        org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+            values, file_);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder clearFile() {
+        file_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000001);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.serialization.js.File file = 1;</code>
+       */
+      public Builder removeFile(int index) {
+        ensureFileIsMutable();
+        file_.remove(index);
+
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.serialization.js.Files)
+    }
+
+    static {
+      defaultInstance = new Files(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.js.Files)
+  }
+
   public interface ClassesOrBuilder extends
       // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.serialization.js.Classes)
       org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptPackageFragment.kt

@@ -49,10 +49,8 @@ class KotlinJavascriptPackageFragment(
     private val fileMap: Map<Int, FileHolder> by lazy {
         loadResource(KotlinJavascriptSerializedResourcePaths.getFileListFilePath(fqName))?.use { rawInput ->
             val input = CodedInputStream.newInstance(rawInput)
-            val count = input.readInt32()
-            val result = mutableListOf<JsProtoBuf.File>()
-            (1..count).forEach { result += JsProtoBuf.File.parseFrom(input) }
-            result.map { it.id to FileHolder(it.annotationList) }.toMap()
+            val filesProto = JsProtoBuf.Files.parseFrom(input).fileOrBuilderList
+            filesProto.map { it.id to FileHolder(it.annotationList) }.toMap()
         }.orEmpty()
     }
 

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.serialization.js
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.ByteString
-import org.jetbrains.kotlin.protobuf.CodedOutputStream
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId