diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/NativeElementsFactory.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/NativeElementsFactory.kt
new file mode 100644
index 0000000..58a026a
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/NativeElementsFactory.kt
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp
+
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.types.KotlinType
+
+interface NativeElementsFactory {
+    fun convertToRDumpDescriptor(descriptor: DeclarationDescriptor): RDumpDescriptor
+    fun convertToRDumpType(type: KotlinType): RDumpType
+    fun convertToRDumpDiagnostic(diagnostic: Diagnostic): RDumpDiagnostic
+}
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDump.proto b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDump.proto
new file mode 100644
index 0000000..f4ea729
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDump.proto
@@ -0,0 +1,56 @@
+package org.jetbrains.kotlin.cli.jvm.compiler.tmp;
+
+option java_outer_classname = "ResolutionDumpProtoBuf";
+
+option optimize_for = LITE_RUNTIME;
+
+message ResolutionResultForFile {
+    optional File file = 1;
+    repeated Element element = 2;
+}
+
+message Element {
+    optional int32 offset = 1;
+    optional string presentable_text = 2;
+
+    // One-of:
+    optional Expression expression = 3;
+}
+
+message Expression {
+    optional Type type = 1;
+
+    // One-of:
+    optional Resolved resolved = 2;
+    optional Error error = 3;
+}
+
+message Resolved {
+    optional Descriptor candidate_descriptor = 1;
+    repeated Type type_argument = 2;
+}
+
+message Error {
+    repeated Diagnostic diagnostic = 1;
+}
+
+message Diagnostic {
+    // TODO: stub
+    optional string diagnostic_family = 1;
+    optional string rendered_text = 2;
+}
+
+message Descriptor {
+    // TODO: stub
+    optional string fqn = 1;
+    repeated Descriptor type_parameter = 2;
+}
+
+message Type {
+    // TODO: stub
+    optional string rendered_type = 1;
+}
+
+message File {
+    optional string relative_path = 1;
+}
\ No newline at end of file
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpBuilder.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpBuilder.kt
new file mode 100644
index 0000000..67a9400
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpBuilder.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.impls.FileBasedRDumpFile
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.impls.RDumpResolvedCall
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrCall
+import org.jetbrains.kotlin.ir.util.dump
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.types.ErrorType
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.jetbrains.kotlin.types.KotlinType
+import java.io.File
+
+class IrBasedResolutionDumpBuilder(
+    private val bindingContext: BindingContext,
+    private val nativeElementsFactory: NativeElementsFactory,
+    private val root: File
+) {
+    fun buildResolutionDumpForFile(irFile: IrFile, correspondingPhysicalFile: File): RDumpForFile {
+        val results = Ir2ResolutionDumpConverter().collectResolutionResultsFromSubtree(irFile)
+        return RDumpForFile(
+            FileBasedRDumpFile(correspondingPhysicalFile, correspondingPhysicalFile.toRelativeString(root)),
+            results
+        )
+    }
+
+    inner class Ir2ResolutionDumpConverter : IrElementVisitorVoid {
+        private val results: MutableList<RDumpElement> = mutableListOf()
+
+        fun collectResolutionResultsFromSubtree(irElement: IrElement): List<RDumpElement> {
+            irElement.accept(this, null)
+            return results
+        }
+
+
+        // === Visitor ===
+
+        override fun visitElement(element: IrElement) {
+            throw IllegalStateException("Shouldn't visit $element")
+        }
+
+        override fun visitDeclaration(declaration: IrDeclaration) {
+            declaration.acceptChildren(this, null)
+        }
+
+        override fun visitBody(body: IrBody) {
+            body.acceptChildren(this, null)
+        }
+
+        // Expressions
+        override fun visitCall(expression: IrCall) {
+            val descriptor = expression.descriptor
+            val rDumpDescriptor = nativeElementsFactory.convertToRDumpDescriptor(descriptor)
+            val rDumpType = nativeElementsFactory.convertToRDumpType(expression.type)
+
+            val typeArguments: MutableList<RDumpType> = mutableListOf()
+            for ((i, typeParameter) in descriptor.typeParameters.withIndex()) {
+                val kotlinTypeArgument = expression.getTypeArgument(i)
+                        ?: ErrorUtils.createErrorType("Error type for typeParameter ${DescriptorRenderer.COMPACT.render(typeParameter)}")
+                typeArguments.add(nativeElementsFactory.convertToRDumpType(kotlinTypeArgument))
+            }
+
+            results.add(RDumpResolvedCall(expression.startOffset, expression.dump(), rDumpType, rDumpDescriptor, typeArguments))
+        }
+    }
+
+    inner class AdditionalDiagnosticInfoProvider {
+    }
+}
\ No newline at end of file
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpDeserializer.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpDeserializer.kt
new file mode 100644
index 0000000..50af354
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpDeserializer.kt
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.impls.*
+import java.io.File
+
+interface ResolutionDumpDeserializer {
+    fun deserializeResolutionResults(bytes: ByteArray): RDumpForFile
+}
+
+class ProtoBufResolutionDumpDeserializer(private val root: File) : ResolutionDumpDeserializer {
+    override fun deserializeResolutionResults(bytes: ByteArray): RDumpForFile {
+        val proto: ResolutionDumpProtoBuf.ResolutionResultForFile = ResolutionDumpProtoBuf.ResolutionResultForFile.parseFrom(bytes)
+
+        return loadDumpForFile(proto)
+    }
+
+    private fun loadDumpForFile(dumpForFileProto: ResolutionDumpProtoBuf.ResolutionResultForFile): RDumpForFile {
+        val file = loadFile(dumpForFileProto.file)
+
+        val elements = dumpForFileProto.elementList.map { loadElement(it) }
+        return RDumpForFile(file, elements)
+    }
+
+    private fun loadElement(elementProto: ResolutionDumpProtoBuf.Element): RDumpElement {
+        val offset = elementProto.offset
+        val presentableText = elementProto.presentableText
+
+        return when {
+            elementProto.hasExpression() -> loadExpression(offset, presentableText, elementProto.expression)
+            else -> throw IllegalStateException("Unknown deserialized resolution dump element") // TODO: do we need better error handling here?
+        }
+    }
+
+    private fun loadExpression(offset: Int, presentableText: String, expressionProto: ResolutionDumpProtoBuf.Expression): RDumpExpression {
+        val type = loadType(expressionProto.type)
+
+        return when {
+            expressionProto.hasError() -> loadError(offset, presentableText, expressionProto.error)
+            expressionProto.hasResolved() -> loadResolved(offset, presentableText, type, expressionProto.resolved)
+            else -> throw IllegalStateException("Unknown deserialized resolution dump element") // TODO: do we need better error handling here?
+        }
+    }
+
+    private fun loadResolved(
+        offset: Int,
+        presentableText: String,
+        type: RDumpType,
+        resolvedProto: ResolutionDumpProtoBuf.Resolved
+    ): RDumpExpression {
+        val typeArguments = resolvedProto.typeArgumentList.map { loadType(it) }
+        val descriptor = loadDescriptor(resolvedProto.candidateDescriptor)
+
+        return RDumpResolvedCall(offset, presentableText, type, descriptor, typeArguments)
+    }
+
+    private fun loadDescriptor(descriptorProto: ResolutionDumpProtoBuf.Descriptor): RDumpDescriptor =
+        TextBasedRDumpDescriptor(
+            descriptorProto.fqn,
+            descriptorProto.typeParameterList.map { loadDescriptor(it) }
+        )
+
+    private fun loadError(offset: Int, presentableText: String, errorProto: ResolutionDumpProtoBuf.Error): RDumpErrorCall {
+        val diagnostics = errorProto.diagnosticList.map { loadDiagnostic(it) }
+        return RDumpErrorCall(offset, presentableText, diagnostics)
+    }
+
+    private fun loadDiagnostic(diagnosticProto: ResolutionDumpProtoBuf.Diagnostic): RDumpDiagnostic {
+        return TextBasedRDumpDiagnostic(diagnosticProto.diagnosticFamily, diagnosticProto.renderedText)
+    }
+
+    private fun loadType(type: ResolutionDumpProtoBuf.Type): RDumpType {
+        return TextBasedRDumpType(type.renderedType)
+    }
+
+    private fun loadFile(fileProto: ResolutionDumpProtoBuf.File): RDumpFile {
+        val file = File(root, fileProto.relativePath)
+        if (!file.exists()) {
+            throw IllegalStateException("Deserialized File with relative path ${fileProto.relativePath} hasn't been resolved relative to root=$root")
+        }
+
+        return FileBasedRDumpFile(file, fileProto.relativePath)
+    }
+}
\ No newline at end of file
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpProtoBuf.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpProtoBuf.java
new file mode 100644
index 0000000..845981c
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpProtoBuf.java
@@ -0,0 +1,5247 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDump.proto
+
+package org.jetbrains.kotlin.cli.jvm.compiler.tmp;
+
+public final class ResolutionDumpProtoBuf {
+  private ResolutionDumpProtoBuf() {}
+  public static void registerAllExtensions(
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite registry) {
+  }
+  public interface ResolutionResultForFileOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionResultForFile)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+     */
+    boolean hasFile();
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File getFile();
+
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element> 
+        getElementList();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element getElement(int index);
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    int getElementCount();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionResultForFile}
+   */
+  public static final class ResolutionResultForFile extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionResultForFile)
+      ResolutionResultForFileOrBuilder {
+    // Use ResolutionResultForFile.newBuilder() to construct.
+    private ResolutionResultForFile(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private ResolutionResultForFile(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final ResolutionResultForFile defaultInstance;
+    public static ResolutionResultForFile getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public ResolutionResultForFile getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private ResolutionResultForFile(
+        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: {
+              org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000001) == 0x00000001)) {
+                subBuilder = file_.toBuilder();
+              }
+              file_ = input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(file_);
+                file_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000001;
+              break;
+            }
+            case 18: {
+              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+                element_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element>();
+                mutable_bitField0_ |= 0x00000002;
+              }
+              element_.add(input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element.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_ & 0x00000002) == 0x00000002)) {
+          element_ = java.util.Collections.unmodifiableList(element_);
+        }
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<ResolutionResultForFile> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<ResolutionResultForFile>() {
+      public ResolutionResultForFile parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new ResolutionResultForFile(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<ResolutionResultForFile> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int FILE_FIELD_NUMBER = 1;
+    private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File file_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+     */
+    public boolean hasFile() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File getFile() {
+      return file_;
+    }
+
+    public static final int ELEMENT_FIELD_NUMBER = 2;
+    private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element> element_;
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element> getElementList() {
+      return element_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    public java.util.List<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ElementOrBuilder> 
+        getElementOrBuilderList() {
+      return element_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    public int getElementCount() {
+      return element_.size();
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element getElement(int index) {
+      return element_.get(index);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ElementOrBuilder getElementOrBuilder(
+        int index) {
+      return element_.get(index);
+    }
+
+    private void initFields() {
+      file_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.getDefaultInstance();
+      element_ = 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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeMessage(1, file_);
+      }
+      for (int i = 0; i < element_.size(); i++) {
+        output.writeMessage(2, element_.get(i));
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(1, file_);
+      }
+      for (int i = 0; i < element_.size(); i++) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(2, element_.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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionResultForFile}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionResultForFile)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFileOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        file_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.getDefaultInstance();
+        bitField0_ = (bitField0_ & ~0x00000001);
+        element_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.file_ = file_;
+        if (((bitField0_ & 0x00000002) == 0x00000002)) {
+          element_ = java.util.Collections.unmodifiableList(element_);
+          bitField0_ = (bitField0_ & ~0x00000002);
+        }
+        result.element_ = element_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile.getDefaultInstance()) return this;
+        if (other.hasFile()) {
+          mergeFile(other.getFile());
+        }
+        if (!other.element_.isEmpty()) {
+          if (element_.isEmpty()) {
+            element_ = other.element_;
+            bitField0_ = (bitField0_ & ~0x00000002);
+          } else {
+            ensureElementIsMutable();
+            element_.addAll(other.element_);
+          }
+          
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolutionResultForFile) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File file_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.getDefaultInstance();
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+       */
+      public boolean hasFile() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File getFile() {
+        return file_;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+       */
+      public Builder setFile(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        file_ = value;
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+       */
+      public Builder setFile(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.Builder builderForValue) {
+        file_ = builderForValue.build();
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+       */
+      public Builder mergeFile(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File value) {
+        if (((bitField0_ & 0x00000001) == 0x00000001) &&
+            file_ != org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.getDefaultInstance()) {
+          file_ =
+            org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.newBuilder(file_).mergeFrom(value).buildPartial();
+        } else {
+          file_ = value;
+        }
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.File file = 1;</code>
+       */
+      public Builder clearFile() {
+        file_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.getDefaultInstance();
+
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element> element_ =
+        java.util.Collections.emptyList();
+      private void ensureElementIsMutable() {
+        if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+          element_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element>(element_);
+          bitField0_ |= 0x00000002;
+         }
+      }
+
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element> getElementList() {
+        return java.util.Collections.unmodifiableList(element_);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public int getElementCount() {
+        return element_.size();
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element getElement(int index) {
+        return element_.get(index);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder setElement(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureElementIsMutable();
+        element_.set(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder setElement(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element.Builder builderForValue) {
+        ensureElementIsMutable();
+        element_.set(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder addElement(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureElementIsMutable();
+        element_.add(value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder addElement(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureElementIsMutable();
+        element_.add(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder addElement(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element.Builder builderForValue) {
+        ensureElementIsMutable();
+        element_.add(builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder addElement(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element.Builder builderForValue) {
+        ensureElementIsMutable();
+        element_.add(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder addAllElement(
+          java.lang.Iterable<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element> values) {
+        ensureElementIsMutable();
+        org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+            values, element_);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder clearElement() {
+        element_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000002);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element element = 2;</code>
+       */
+      public Builder removeElement(int index) {
+        ensureElementIsMutable();
+        element_.remove(index);
+
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionResultForFile)
+    }
+
+    static {
+      defaultInstance = new ResolutionResultForFile(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionResultForFile)
+  }
+
+  public interface ElementOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional int32 offset = 1;</code>
+     */
+    boolean hasOffset();
+    /**
+     * <code>optional int32 offset = 1;</code>
+     */
+    int getOffset();
+
+    /**
+     * <code>optional string presentable_text = 2;</code>
+     */
+    boolean hasPresentableText();
+    /**
+     * <code>optional string presentable_text = 2;</code>
+     */
+    java.lang.String getPresentableText();
+    /**
+     * <code>optional string presentable_text = 2;</code>
+     */
+    org.jetbrains.kotlin.protobuf.ByteString
+        getPresentableTextBytes();
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    boolean hasExpression();
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression getExpression();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element}
+   */
+  public static final class Element extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element)
+      ElementOrBuilder {
+    // Use Element.newBuilder() to construct.
+    private Element(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Element(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Element defaultInstance;
+    public static Element getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Element getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Element(
+        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 8: {
+              bitField0_ |= 0x00000001;
+              offset_ = input.readInt32();
+              break;
+            }
+            case 18: {
+              org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes();
+              bitField0_ |= 0x00000002;
+              presentableText_ = bs;
+              break;
+            }
+            case 26: {
+              org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000004) == 0x00000004)) {
+                subBuilder = expression_.toBuilder();
+              }
+              expression_ = input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(expression_);
+                expression_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000004;
+              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 {
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Element> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Element>() {
+      public Element parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Element(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Element> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int OFFSET_FIELD_NUMBER = 1;
+    private int offset_;
+    /**
+     * <code>optional int32 offset = 1;</code>
+     */
+    public boolean hasOffset() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional int32 offset = 1;</code>
+     */
+    public int getOffset() {
+      return offset_;
+    }
+
+    public static final int PRESENTABLE_TEXT_FIELD_NUMBER = 2;
+    private java.lang.Object presentableText_;
+    /**
+     * <code>optional string presentable_text = 2;</code>
+     */
+    public boolean hasPresentableText() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional string presentable_text = 2;</code>
+     */
+    public java.lang.String getPresentableText() {
+      java.lang.Object ref = presentableText_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        org.jetbrains.kotlin.protobuf.ByteString bs = 
+            (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          presentableText_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string presentable_text = 2;</code>
+     */
+    public org.jetbrains.kotlin.protobuf.ByteString
+        getPresentableTextBytes() {
+      java.lang.Object ref = presentableText_;
+      if (ref instanceof java.lang.String) {
+        org.jetbrains.kotlin.protobuf.ByteString b = 
+            org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        presentableText_ = b;
+        return b;
+      } else {
+        return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+      }
+    }
+
+    public static final int EXPRESSION_FIELD_NUMBER = 3;
+    private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression expression_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    public boolean hasExpression() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression getExpression() {
+      return expression_;
+    }
+
+    private void initFields() {
+      offset_ = 0;
+      presentableText_ = "";
+      expression_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.getDefaultInstance();
+    }
+    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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeInt32(1, offset_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, getPresentableTextBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeMessage(3, expression_);
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeInt32Size(1, offset_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeBytesSize(2, getPresentableTextBytes());
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(3, expression_);
+      }
+      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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ElementOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        offset_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000001);
+        presentableText_ = "";
+        bitField0_ = (bitField0_ & ~0x00000002);
+        expression_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.getDefaultInstance();
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.offset_ = offset_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.presentableText_ = presentableText_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.expression_ = expression_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element.getDefaultInstance()) return this;
+        if (other.hasOffset()) {
+          setOffset(other.getOffset());
+        }
+        if (other.hasPresentableText()) {
+          bitField0_ |= 0x00000002;
+          presentableText_ = other.presentableText_;
+          
+        }
+        if (other.hasExpression()) {
+          mergeExpression(other.getExpression());
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Element) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private int offset_ ;
+      /**
+       * <code>optional int32 offset = 1;</code>
+       */
+      public boolean hasOffset() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional int32 offset = 1;</code>
+       */
+      public int getOffset() {
+        return offset_;
+      }
+      /**
+       * <code>optional int32 offset = 1;</code>
+       */
+      public Builder setOffset(int value) {
+        bitField0_ |= 0x00000001;
+        offset_ = value;
+        
+        return this;
+      }
+      /**
+       * <code>optional int32 offset = 1;</code>
+       */
+      public Builder clearOffset() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        offset_ = 0;
+        
+        return this;
+      }
+
+      private java.lang.Object presentableText_ = "";
+      /**
+       * <code>optional string presentable_text = 2;</code>
+       */
+      public boolean hasPresentableText() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional string presentable_text = 2;</code>
+       */
+      public java.lang.String getPresentableText() {
+        java.lang.Object ref = presentableText_;
+        if (!(ref instanceof java.lang.String)) {
+          org.jetbrains.kotlin.protobuf.ByteString bs =
+              (org.jetbrains.kotlin.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          if (bs.isValidUtf8()) {
+            presentableText_ = s;
+          }
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string presentable_text = 2;</code>
+       */
+      public org.jetbrains.kotlin.protobuf.ByteString
+          getPresentableTextBytes() {
+        java.lang.Object ref = presentableText_;
+        if (ref instanceof String) {
+          org.jetbrains.kotlin.protobuf.ByteString b = 
+              org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          presentableText_ = b;
+          return b;
+        } else {
+          return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string presentable_text = 2;</code>
+       */
+      public Builder setPresentableText(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        presentableText_ = value;
+        
+        return this;
+      }
+      /**
+       * <code>optional string presentable_text = 2;</code>
+       */
+      public Builder clearPresentableText() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        presentableText_ = getDefaultInstance().getPresentableText();
+        
+        return this;
+      }
+      /**
+       * <code>optional string presentable_text = 2;</code>
+       */
+      public Builder setPresentableTextBytes(
+          org.jetbrains.kotlin.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        presentableText_ = value;
+        
+        return this;
+      }
+
+      private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression expression_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.getDefaultInstance();
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public boolean hasExpression() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression getExpression() {
+        return expression_;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder setExpression(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        expression_ = value;
+
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder setExpression(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.Builder builderForValue) {
+        expression_ = builderForValue.build();
+
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder mergeExpression(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression value) {
+        if (((bitField0_ & 0x00000004) == 0x00000004) &&
+            expression_ != org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.getDefaultInstance()) {
+          expression_ =
+            org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.newBuilder(expression_).mergeFrom(value).buildPartial();
+        } else {
+          expression_ = value;
+        }
+
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression expression = 3;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder clearExpression() {
+        expression_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.getDefaultInstance();
+
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element)
+    }
+
+    static {
+      defaultInstance = new Element(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Element)
+  }
+
+  public interface ExpressionOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+     */
+    boolean hasType();
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type getType();
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    boolean hasResolved();
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved getResolved();
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+     */
+    boolean hasError();
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error getError();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression}
+   */
+  public static final class Expression extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression)
+      ExpressionOrBuilder {
+    // Use Expression.newBuilder() to construct.
+    private Expression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Expression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Expression defaultInstance;
+    public static Expression getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Expression getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Expression(
+        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: {
+              org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000001) == 0x00000001)) {
+                subBuilder = type_.toBuilder();
+              }
+              type_ = input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(type_);
+                type_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000001;
+              break;
+            }
+            case 18: {
+              org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000002) == 0x00000002)) {
+                subBuilder = resolved_.toBuilder();
+              }
+              resolved_ = input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(resolved_);
+                resolved_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000002;
+              break;
+            }
+            case 26: {
+              org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000004) == 0x00000004)) {
+                subBuilder = error_.toBuilder();
+              }
+              error_ = input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(error_);
+                error_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000004;
+              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 {
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Expression> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Expression>() {
+      public Expression parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Expression(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Expression> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int TYPE_FIELD_NUMBER = 1;
+    private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type type_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+     */
+    public boolean hasType() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type getType() {
+      return type_;
+    }
+
+    public static final int RESOLVED_FIELD_NUMBER = 2;
+    private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved resolved_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    public boolean hasResolved() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+     *
+     * <pre>
+     * One-of:
+     * </pre>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved getResolved() {
+      return resolved_;
+    }
+
+    public static final int ERROR_FIELD_NUMBER = 3;
+    private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error error_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+     */
+    public boolean hasError() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error getError() {
+      return error_;
+    }
+
+    private void initFields() {
+      type_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.getDefaultInstance();
+      resolved_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.getDefaultInstance();
+      error_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.getDefaultInstance();
+    }
+    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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeMessage(1, type_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeMessage(2, resolved_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeMessage(3, error_);
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(1, type_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(2, resolved_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(3, error_);
+      }
+      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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ExpressionOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        type_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.getDefaultInstance();
+        bitField0_ = (bitField0_ & ~0x00000001);
+        resolved_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.getDefaultInstance();
+        bitField0_ = (bitField0_ & ~0x00000002);
+        error_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.getDefaultInstance();
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.type_ = type_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.resolved_ = resolved_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
+        result.error_ = error_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression.getDefaultInstance()) return this;
+        if (other.hasType()) {
+          mergeType(other.getType());
+        }
+        if (other.hasResolved()) {
+          mergeResolved(other.getResolved());
+        }
+        if (other.hasError()) {
+          mergeError(other.getError());
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Expression) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type type_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.getDefaultInstance();
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+       */
+      public boolean hasType() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type getType() {
+        return type_;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+       */
+      public Builder setType(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        type_ = value;
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+       */
+      public Builder setType(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.Builder builderForValue) {
+        type_ = builderForValue.build();
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+       */
+      public Builder mergeType(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type value) {
+        if (((bitField0_ & 0x00000001) == 0x00000001) &&
+            type_ != org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.getDefaultInstance()) {
+          type_ =
+            org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.newBuilder(type_).mergeFrom(value).buildPartial();
+        } else {
+          type_ = value;
+        }
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type = 1;</code>
+       */
+      public Builder clearType() {
+        type_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.getDefaultInstance();
+
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved resolved_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.getDefaultInstance();
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public boolean hasResolved() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved getResolved() {
+        return resolved_;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder setResolved(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        resolved_ = value;
+
+        bitField0_ |= 0x00000002;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder setResolved(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.Builder builderForValue) {
+        resolved_ = builderForValue.build();
+
+        bitField0_ |= 0x00000002;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder mergeResolved(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved value) {
+        if (((bitField0_ & 0x00000002) == 0x00000002) &&
+            resolved_ != org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.getDefaultInstance()) {
+          resolved_ =
+            org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.newBuilder(resolved_).mergeFrom(value).buildPartial();
+        } else {
+          resolved_ = value;
+        }
+
+        bitField0_ |= 0x00000002;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved resolved = 2;</code>
+       *
+       * <pre>
+       * One-of:
+       * </pre>
+       */
+      public Builder clearResolved() {
+        resolved_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.getDefaultInstance();
+
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error error_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.getDefaultInstance();
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+       */
+      public boolean hasError() {
+        return ((bitField0_ & 0x00000004) == 0x00000004);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error getError() {
+        return error_;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+       */
+      public Builder setError(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        error_ = value;
+
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+       */
+      public Builder setError(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.Builder builderForValue) {
+        error_ = builderForValue.build();
+
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+       */
+      public Builder mergeError(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error value) {
+        if (((bitField0_ & 0x00000004) == 0x00000004) &&
+            error_ != org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.getDefaultInstance()) {
+          error_ =
+            org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.newBuilder(error_).mergeFrom(value).buildPartial();
+        } else {
+          error_ = value;
+        }
+
+        bitField0_ |= 0x00000004;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error error = 3;</code>
+       */
+      public Builder clearError() {
+        error_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.getDefaultInstance();
+
+        bitField0_ = (bitField0_ & ~0x00000004);
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression)
+    }
+
+    static {
+      defaultInstance = new Expression(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Expression)
+  }
+
+  public interface ResolvedOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+     */
+    boolean hasCandidateDescriptor();
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor getCandidateDescriptor();
+
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type> 
+        getTypeArgumentList();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type getTypeArgument(int index);
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    int getTypeArgumentCount();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved}
+   */
+  public static final class Resolved extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved)
+      ResolvedOrBuilder {
+    // Use Resolved.newBuilder() to construct.
+    private Resolved(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Resolved(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Resolved defaultInstance;
+    public static Resolved getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Resolved getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Resolved(
+        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: {
+              org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.Builder subBuilder = null;
+              if (((bitField0_ & 0x00000001) == 0x00000001)) {
+                subBuilder = candidateDescriptor_.toBuilder();
+              }
+              candidateDescriptor_ = input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.PARSER, extensionRegistry);
+              if (subBuilder != null) {
+                subBuilder.mergeFrom(candidateDescriptor_);
+                candidateDescriptor_ = subBuilder.buildPartial();
+              }
+              bitField0_ |= 0x00000001;
+              break;
+            }
+            case 18: {
+              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+                typeArgument_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type>();
+                mutable_bitField0_ |= 0x00000002;
+              }
+              typeArgument_.add(input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.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_ & 0x00000002) == 0x00000002)) {
+          typeArgument_ = java.util.Collections.unmodifiableList(typeArgument_);
+        }
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Resolved> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Resolved>() {
+      public Resolved parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Resolved(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Resolved> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int CANDIDATE_DESCRIPTOR_FIELD_NUMBER = 1;
+    private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor candidateDescriptor_;
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+     */
+    public boolean hasCandidateDescriptor() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor getCandidateDescriptor() {
+      return candidateDescriptor_;
+    }
+
+    public static final int TYPE_ARGUMENT_FIELD_NUMBER = 2;
+    private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type> typeArgument_;
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type> getTypeArgumentList() {
+      return typeArgument_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    public java.util.List<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.TypeOrBuilder> 
+        getTypeArgumentOrBuilderList() {
+      return typeArgument_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    public int getTypeArgumentCount() {
+      return typeArgument_.size();
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type getTypeArgument(int index) {
+      return typeArgument_.get(index);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.TypeOrBuilder getTypeArgumentOrBuilder(
+        int index) {
+      return typeArgument_.get(index);
+    }
+
+    private void initFields() {
+      candidateDescriptor_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.getDefaultInstance();
+      typeArgument_ = 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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeMessage(1, candidateDescriptor_);
+      }
+      for (int i = 0; i < typeArgument_.size(); i++) {
+        output.writeMessage(2, typeArgument_.get(i));
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(1, candidateDescriptor_);
+      }
+      for (int i = 0; i < typeArgument_.size(); i++) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(2, typeArgument_.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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ResolvedOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        candidateDescriptor_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.getDefaultInstance();
+        bitField0_ = (bitField0_ & ~0x00000001);
+        typeArgument_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.candidateDescriptor_ = candidateDescriptor_;
+        if (((bitField0_ & 0x00000002) == 0x00000002)) {
+          typeArgument_ = java.util.Collections.unmodifiableList(typeArgument_);
+          bitField0_ = (bitField0_ & ~0x00000002);
+        }
+        result.typeArgument_ = typeArgument_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved.getDefaultInstance()) return this;
+        if (other.hasCandidateDescriptor()) {
+          mergeCandidateDescriptor(other.getCandidateDescriptor());
+        }
+        if (!other.typeArgument_.isEmpty()) {
+          if (typeArgument_.isEmpty()) {
+            typeArgument_ = other.typeArgument_;
+            bitField0_ = (bitField0_ & ~0x00000002);
+          } else {
+            ensureTypeArgumentIsMutable();
+            typeArgument_.addAll(other.typeArgument_);
+          }
+          
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Resolved) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor candidateDescriptor_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.getDefaultInstance();
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+       */
+      public boolean hasCandidateDescriptor() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor getCandidateDescriptor() {
+        return candidateDescriptor_;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+       */
+      public Builder setCandidateDescriptor(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        candidateDescriptor_ = value;
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+       */
+      public Builder setCandidateDescriptor(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.Builder builderForValue) {
+        candidateDescriptor_ = builderForValue.build();
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+       */
+      public Builder mergeCandidateDescriptor(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor value) {
+        if (((bitField0_ & 0x00000001) == 0x00000001) &&
+            candidateDescriptor_ != org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.getDefaultInstance()) {
+          candidateDescriptor_ =
+            org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.newBuilder(candidateDescriptor_).mergeFrom(value).buildPartial();
+        } else {
+          candidateDescriptor_ = value;
+        }
+
+        bitField0_ |= 0x00000001;
+        return this;
+      }
+      /**
+       * <code>optional .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor candidate_descriptor = 1;</code>
+       */
+      public Builder clearCandidateDescriptor() {
+        candidateDescriptor_ = org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.getDefaultInstance();
+
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type> typeArgument_ =
+        java.util.Collections.emptyList();
+      private void ensureTypeArgumentIsMutable() {
+        if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+          typeArgument_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type>(typeArgument_);
+          bitField0_ |= 0x00000002;
+         }
+      }
+
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type> getTypeArgumentList() {
+        return java.util.Collections.unmodifiableList(typeArgument_);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public int getTypeArgumentCount() {
+        return typeArgument_.size();
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type getTypeArgument(int index) {
+        return typeArgument_.get(index);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder setTypeArgument(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureTypeArgumentIsMutable();
+        typeArgument_.set(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder setTypeArgument(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.Builder builderForValue) {
+        ensureTypeArgumentIsMutable();
+        typeArgument_.set(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder addTypeArgument(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureTypeArgumentIsMutable();
+        typeArgument_.add(value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder addTypeArgument(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureTypeArgumentIsMutable();
+        typeArgument_.add(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder addTypeArgument(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.Builder builderForValue) {
+        ensureTypeArgumentIsMutable();
+        typeArgument_.add(builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder addTypeArgument(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.Builder builderForValue) {
+        ensureTypeArgumentIsMutable();
+        typeArgument_.add(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder addAllTypeArgument(
+          java.lang.Iterable<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type> values) {
+        ensureTypeArgumentIsMutable();
+        org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+            values, typeArgument_);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder clearTypeArgument() {
+        typeArgument_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000002);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type type_argument = 2;</code>
+       */
+      public Builder removeTypeArgument(int index) {
+        ensureTypeArgumentIsMutable();
+        typeArgument_.remove(index);
+
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved)
+    }
+
+    static {
+      defaultInstance = new Resolved(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Resolved)
+  }
+
+  public interface ErrorOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic> 
+        getDiagnosticList();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic getDiagnostic(int index);
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    int getDiagnosticCount();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error}
+   */
+  public static final class Error extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error)
+      ErrorOrBuilder {
+    // Use Error.newBuilder() to construct.
+    private Error(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Error(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Error defaultInstance;
+    public static Error getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Error getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Error(
+        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)) {
+                diagnostic_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic>();
+                mutable_bitField0_ |= 0x00000001;
+              }
+              diagnostic_.add(input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic.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)) {
+          diagnostic_ = java.util.Collections.unmodifiableList(diagnostic_);
+        }
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Error> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Error>() {
+      public Error parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Error(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Error> getParserForType() {
+      return PARSER;
+    }
+
+    public static final int DIAGNOSTIC_FIELD_NUMBER = 1;
+    private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic> diagnostic_;
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic> getDiagnosticList() {
+      return diagnostic_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    public java.util.List<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.DiagnosticOrBuilder> 
+        getDiagnosticOrBuilderList() {
+      return diagnostic_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    public int getDiagnosticCount() {
+      return diagnostic_.size();
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic getDiagnostic(int index) {
+      return diagnostic_.get(index);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.DiagnosticOrBuilder getDiagnosticOrBuilder(
+        int index) {
+      return diagnostic_.get(index);
+    }
+
+    private void initFields() {
+      diagnostic_ = 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();
+      for (int i = 0; i < diagnostic_.size(); i++) {
+        output.writeMessage(1, diagnostic_.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 < diagnostic_.size(); i++) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(1, diagnostic_.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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.ErrorOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        diagnostic_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error(this);
+        int from_bitField0_ = bitField0_;
+        if (((bitField0_ & 0x00000001) == 0x00000001)) {
+          diagnostic_ = java.util.Collections.unmodifiableList(diagnostic_);
+          bitField0_ = (bitField0_ & ~0x00000001);
+        }
+        result.diagnostic_ = diagnostic_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error.getDefaultInstance()) return this;
+        if (!other.diagnostic_.isEmpty()) {
+          if (diagnostic_.isEmpty()) {
+            diagnostic_ = other.diagnostic_;
+            bitField0_ = (bitField0_ & ~0x00000001);
+          } else {
+            ensureDiagnosticIsMutable();
+            diagnostic_.addAll(other.diagnostic_);
+          }
+          
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Error) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic> diagnostic_ =
+        java.util.Collections.emptyList();
+      private void ensureDiagnosticIsMutable() {
+        if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+          diagnostic_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic>(diagnostic_);
+          bitField0_ |= 0x00000001;
+         }
+      }
+
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic> getDiagnosticList() {
+        return java.util.Collections.unmodifiableList(diagnostic_);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public int getDiagnosticCount() {
+        return diagnostic_.size();
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic getDiagnostic(int index) {
+        return diagnostic_.get(index);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder setDiagnostic(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureDiagnosticIsMutable();
+        diagnostic_.set(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder setDiagnostic(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic.Builder builderForValue) {
+        ensureDiagnosticIsMutable();
+        diagnostic_.set(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder addDiagnostic(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureDiagnosticIsMutable();
+        diagnostic_.add(value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder addDiagnostic(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureDiagnosticIsMutable();
+        diagnostic_.add(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder addDiagnostic(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic.Builder builderForValue) {
+        ensureDiagnosticIsMutable();
+        diagnostic_.add(builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder addDiagnostic(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic.Builder builderForValue) {
+        ensureDiagnosticIsMutable();
+        diagnostic_.add(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder addAllDiagnostic(
+          java.lang.Iterable<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic> values) {
+        ensureDiagnosticIsMutable();
+        org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+            values, diagnostic_);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder clearDiagnostic() {
+        diagnostic_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000001);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic diagnostic = 1;</code>
+       */
+      public Builder removeDiagnostic(int index) {
+        ensureDiagnosticIsMutable();
+        diagnostic_.remove(index);
+
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error)
+    }
+
+    static {
+      defaultInstance = new Error(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Error)
+  }
+
+  public interface DiagnosticOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional string diagnostic_family = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    boolean hasDiagnosticFamily();
+    /**
+     * <code>optional string diagnostic_family = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    java.lang.String getDiagnosticFamily();
+    /**
+     * <code>optional string diagnostic_family = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    org.jetbrains.kotlin.protobuf.ByteString
+        getDiagnosticFamilyBytes();
+
+    /**
+     * <code>optional string rendered_text = 2;</code>
+     */
+    boolean hasRenderedText();
+    /**
+     * <code>optional string rendered_text = 2;</code>
+     */
+    java.lang.String getRenderedText();
+    /**
+     * <code>optional string rendered_text = 2;</code>
+     */
+    org.jetbrains.kotlin.protobuf.ByteString
+        getRenderedTextBytes();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic}
+   */
+  public static final class Diagnostic extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic)
+      DiagnosticOrBuilder {
+    // Use Diagnostic.newBuilder() to construct.
+    private Diagnostic(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Diagnostic(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Diagnostic defaultInstance;
+    public static Diagnostic getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Diagnostic getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Diagnostic(
+        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: {
+              org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes();
+              bitField0_ |= 0x00000001;
+              diagnosticFamily_ = bs;
+              break;
+            }
+            case 18: {
+              org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes();
+              bitField0_ |= 0x00000002;
+              renderedText_ = bs;
+              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 {
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Diagnostic> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Diagnostic>() {
+      public Diagnostic parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Diagnostic(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Diagnostic> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int DIAGNOSTIC_FAMILY_FIELD_NUMBER = 1;
+    private java.lang.Object diagnosticFamily_;
+    /**
+     * <code>optional string diagnostic_family = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public boolean hasDiagnosticFamily() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional string diagnostic_family = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public java.lang.String getDiagnosticFamily() {
+      java.lang.Object ref = diagnosticFamily_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        org.jetbrains.kotlin.protobuf.ByteString bs = 
+            (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          diagnosticFamily_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string diagnostic_family = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public org.jetbrains.kotlin.protobuf.ByteString
+        getDiagnosticFamilyBytes() {
+      java.lang.Object ref = diagnosticFamily_;
+      if (ref instanceof java.lang.String) {
+        org.jetbrains.kotlin.protobuf.ByteString b = 
+            org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        diagnosticFamily_ = b;
+        return b;
+      } else {
+        return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+      }
+    }
+
+    public static final int RENDERED_TEXT_FIELD_NUMBER = 2;
+    private java.lang.Object renderedText_;
+    /**
+     * <code>optional string rendered_text = 2;</code>
+     */
+    public boolean hasRenderedText() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional string rendered_text = 2;</code>
+     */
+    public java.lang.String getRenderedText() {
+      java.lang.Object ref = renderedText_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        org.jetbrains.kotlin.protobuf.ByteString bs = 
+            (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          renderedText_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string rendered_text = 2;</code>
+     */
+    public org.jetbrains.kotlin.protobuf.ByteString
+        getRenderedTextBytes() {
+      java.lang.Object ref = renderedText_;
+      if (ref instanceof java.lang.String) {
+        org.jetbrains.kotlin.protobuf.ByteString b = 
+            org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        renderedText_ = b;
+        return b;
+      } else {
+        return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      diagnosticFamily_ = "";
+      renderedText_ = "";
+    }
+    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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getDiagnosticFamilyBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeBytes(2, getRenderedTextBytes());
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeBytesSize(1, getDiagnosticFamilyBytes());
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeBytesSize(2, getRenderedTextBytes());
+      }
+      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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.DiagnosticOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        diagnosticFamily_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        renderedText_ = "";
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.diagnosticFamily_ = diagnosticFamily_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.renderedText_ = renderedText_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic.getDefaultInstance()) return this;
+        if (other.hasDiagnosticFamily()) {
+          bitField0_ |= 0x00000001;
+          diagnosticFamily_ = other.diagnosticFamily_;
+          
+        }
+        if (other.hasRenderedText()) {
+          bitField0_ |= 0x00000002;
+          renderedText_ = other.renderedText_;
+          
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Diagnostic) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private java.lang.Object diagnosticFamily_ = "";
+      /**
+       * <code>optional string diagnostic_family = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public boolean hasDiagnosticFamily() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional string diagnostic_family = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public java.lang.String getDiagnosticFamily() {
+        java.lang.Object ref = diagnosticFamily_;
+        if (!(ref instanceof java.lang.String)) {
+          org.jetbrains.kotlin.protobuf.ByteString bs =
+              (org.jetbrains.kotlin.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          if (bs.isValidUtf8()) {
+            diagnosticFamily_ = s;
+          }
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string diagnostic_family = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public org.jetbrains.kotlin.protobuf.ByteString
+          getDiagnosticFamilyBytes() {
+        java.lang.Object ref = diagnosticFamily_;
+        if (ref instanceof String) {
+          org.jetbrains.kotlin.protobuf.ByteString b = 
+              org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          diagnosticFamily_ = b;
+          return b;
+        } else {
+          return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string diagnostic_family = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder setDiagnosticFamily(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        diagnosticFamily_ = value;
+        
+        return this;
+      }
+      /**
+       * <code>optional string diagnostic_family = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder clearDiagnosticFamily() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        diagnosticFamily_ = getDefaultInstance().getDiagnosticFamily();
+        
+        return this;
+      }
+      /**
+       * <code>optional string diagnostic_family = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder setDiagnosticFamilyBytes(
+          org.jetbrains.kotlin.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        diagnosticFamily_ = value;
+        
+        return this;
+      }
+
+      private java.lang.Object renderedText_ = "";
+      /**
+       * <code>optional string rendered_text = 2;</code>
+       */
+      public boolean hasRenderedText() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>optional string rendered_text = 2;</code>
+       */
+      public java.lang.String getRenderedText() {
+        java.lang.Object ref = renderedText_;
+        if (!(ref instanceof java.lang.String)) {
+          org.jetbrains.kotlin.protobuf.ByteString bs =
+              (org.jetbrains.kotlin.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          if (bs.isValidUtf8()) {
+            renderedText_ = s;
+          }
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string rendered_text = 2;</code>
+       */
+      public org.jetbrains.kotlin.protobuf.ByteString
+          getRenderedTextBytes() {
+        java.lang.Object ref = renderedText_;
+        if (ref instanceof String) {
+          org.jetbrains.kotlin.protobuf.ByteString b = 
+              org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          renderedText_ = b;
+          return b;
+        } else {
+          return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string rendered_text = 2;</code>
+       */
+      public Builder setRenderedText(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        renderedText_ = value;
+        
+        return this;
+      }
+      /**
+       * <code>optional string rendered_text = 2;</code>
+       */
+      public Builder clearRenderedText() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        renderedText_ = getDefaultInstance().getRenderedText();
+        
+        return this;
+      }
+      /**
+       * <code>optional string rendered_text = 2;</code>
+       */
+      public Builder setRenderedTextBytes(
+          org.jetbrains.kotlin.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000002;
+        renderedText_ = value;
+        
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic)
+    }
+
+    static {
+      defaultInstance = new Diagnostic(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Diagnostic)
+  }
+
+  public interface DescriptorOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional string fqn = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    boolean hasFqn();
+    /**
+     * <code>optional string fqn = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    java.lang.String getFqn();
+    /**
+     * <code>optional string fqn = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    org.jetbrains.kotlin.protobuf.ByteString
+        getFqnBytes();
+
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor> 
+        getTypeParameterList();
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor getTypeParameter(int index);
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    int getTypeParameterCount();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor}
+   */
+  public static final class Descriptor extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor)
+      DescriptorOrBuilder {
+    // Use Descriptor.newBuilder() to construct.
+    private Descriptor(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Descriptor(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Descriptor defaultInstance;
+    public static Descriptor getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Descriptor getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Descriptor(
+        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: {
+              org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes();
+              bitField0_ |= 0x00000001;
+              fqn_ = bs;
+              break;
+            }
+            case 18: {
+              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+                typeParameter_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor>();
+                mutable_bitField0_ |= 0x00000002;
+              }
+              typeParameter_.add(input.readMessage(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.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_ & 0x00000002) == 0x00000002)) {
+          typeParameter_ = java.util.Collections.unmodifiableList(typeParameter_);
+        }
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Descriptor> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Descriptor>() {
+      public Descriptor parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Descriptor(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Descriptor> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int FQN_FIELD_NUMBER = 1;
+    private java.lang.Object fqn_;
+    /**
+     * <code>optional string fqn = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public boolean hasFqn() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional string fqn = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public java.lang.String getFqn() {
+      java.lang.Object ref = fqn_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        org.jetbrains.kotlin.protobuf.ByteString bs = 
+            (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          fqn_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string fqn = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public org.jetbrains.kotlin.protobuf.ByteString
+        getFqnBytes() {
+      java.lang.Object ref = fqn_;
+      if (ref instanceof java.lang.String) {
+        org.jetbrains.kotlin.protobuf.ByteString b = 
+            org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        fqn_ = b;
+        return b;
+      } else {
+        return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+      }
+    }
+
+    public static final int TYPE_PARAMETER_FIELD_NUMBER = 2;
+    private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor> typeParameter_;
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor> getTypeParameterList() {
+      return typeParameter_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    public java.util.List<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.DescriptorOrBuilder> 
+        getTypeParameterOrBuilderList() {
+      return typeParameter_;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    public int getTypeParameterCount() {
+      return typeParameter_.size();
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor getTypeParameter(int index) {
+      return typeParameter_.get(index);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+     */
+    public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.DescriptorOrBuilder getTypeParameterOrBuilder(
+        int index) {
+      return typeParameter_.get(index);
+    }
+
+    private void initFields() {
+      fqn_ = "";
+      typeParameter_ = 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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getFqnBytes());
+      }
+      for (int i = 0; i < typeParameter_.size(); i++) {
+        output.writeMessage(2, typeParameter_.get(i));
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeBytesSize(1, getFqnBytes());
+      }
+      for (int i = 0; i < typeParameter_.size(); i++) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeMessageSize(2, typeParameter_.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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.DescriptorOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        fqn_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        typeParameter_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.fqn_ = fqn_;
+        if (((bitField0_ & 0x00000002) == 0x00000002)) {
+          typeParameter_ = java.util.Collections.unmodifiableList(typeParameter_);
+          bitField0_ = (bitField0_ & ~0x00000002);
+        }
+        result.typeParameter_ = typeParameter_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.getDefaultInstance()) return this;
+        if (other.hasFqn()) {
+          bitField0_ |= 0x00000001;
+          fqn_ = other.fqn_;
+          
+        }
+        if (!other.typeParameter_.isEmpty()) {
+          if (typeParameter_.isEmpty()) {
+            typeParameter_ = other.typeParameter_;
+            bitField0_ = (bitField0_ & ~0x00000002);
+          } else {
+            ensureTypeParameterIsMutable();
+            typeParameter_.addAll(other.typeParameter_);
+          }
+          
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private java.lang.Object fqn_ = "";
+      /**
+       * <code>optional string fqn = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public boolean hasFqn() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional string fqn = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public java.lang.String getFqn() {
+        java.lang.Object ref = fqn_;
+        if (!(ref instanceof java.lang.String)) {
+          org.jetbrains.kotlin.protobuf.ByteString bs =
+              (org.jetbrains.kotlin.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          if (bs.isValidUtf8()) {
+            fqn_ = s;
+          }
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string fqn = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public org.jetbrains.kotlin.protobuf.ByteString
+          getFqnBytes() {
+        java.lang.Object ref = fqn_;
+        if (ref instanceof String) {
+          org.jetbrains.kotlin.protobuf.ByteString b = 
+              org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          fqn_ = b;
+          return b;
+        } else {
+          return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string fqn = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder setFqn(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        fqn_ = value;
+        
+        return this;
+      }
+      /**
+       * <code>optional string fqn = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder clearFqn() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        fqn_ = getDefaultInstance().getFqn();
+        
+        return this;
+      }
+      /**
+       * <code>optional string fqn = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder setFqnBytes(
+          org.jetbrains.kotlin.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        fqn_ = value;
+        
+        return this;
+      }
+
+      private java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor> typeParameter_ =
+        java.util.Collections.emptyList();
+      private void ensureTypeParameterIsMutable() {
+        if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+          typeParameter_ = new java.util.ArrayList<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor>(typeParameter_);
+          bitField0_ |= 0x00000002;
+         }
+      }
+
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public java.util.List<org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor> getTypeParameterList() {
+        return java.util.Collections.unmodifiableList(typeParameter_);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public int getTypeParameterCount() {
+        return typeParameter_.size();
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor getTypeParameter(int index) {
+        return typeParameter_.get(index);
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder setTypeParameter(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureTypeParameterIsMutable();
+        typeParameter_.set(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder setTypeParameter(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.Builder builderForValue) {
+        ensureTypeParameterIsMutable();
+        typeParameter_.set(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder addTypeParameter(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureTypeParameterIsMutable();
+        typeParameter_.add(value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder addTypeParameter(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor value) {
+        if (value == null) {
+          throw new NullPointerException();
+        }
+        ensureTypeParameterIsMutable();
+        typeParameter_.add(index, value);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder addTypeParameter(
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.Builder builderForValue) {
+        ensureTypeParameterIsMutable();
+        typeParameter_.add(builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder addTypeParameter(
+          int index, org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor.Builder builderForValue) {
+        ensureTypeParameterIsMutable();
+        typeParameter_.add(index, builderForValue.build());
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder addAllTypeParameter(
+          java.lang.Iterable<? extends org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Descriptor> values) {
+        ensureTypeParameterIsMutable();
+        org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+            values, typeParameter_);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder clearTypeParameter() {
+        typeParameter_ = java.util.Collections.emptyList();
+        bitField0_ = (bitField0_ & ~0x00000002);
+
+        return this;
+      }
+      /**
+       * <code>repeated .org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor type_parameter = 2;</code>
+       */
+      public Builder removeTypeParameter(int index) {
+        ensureTypeParameterIsMutable();
+        typeParameter_.remove(index);
+
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor)
+    }
+
+    static {
+      defaultInstance = new Descriptor(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Descriptor)
+  }
+
+  public interface TypeOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional string rendered_type = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    boolean hasRenderedType();
+    /**
+     * <code>optional string rendered_type = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    java.lang.String getRenderedType();
+    /**
+     * <code>optional string rendered_type = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    org.jetbrains.kotlin.protobuf.ByteString
+        getRenderedTypeBytes();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type}
+   */
+  public static final class Type extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type)
+      TypeOrBuilder {
+    // Use Type.newBuilder() to construct.
+    private Type(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Type(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final Type defaultInstance;
+    public static Type getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Type getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private Type(
+        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: {
+              org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes();
+              bitField0_ |= 0x00000001;
+              renderedType_ = bs;
+              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 {
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<Type> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<Type>() {
+      public Type parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new Type(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<Type> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int RENDERED_TYPE_FIELD_NUMBER = 1;
+    private java.lang.Object renderedType_;
+    /**
+     * <code>optional string rendered_type = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public boolean hasRenderedType() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional string rendered_type = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public java.lang.String getRenderedType() {
+      java.lang.Object ref = renderedType_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        org.jetbrains.kotlin.protobuf.ByteString bs = 
+            (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          renderedType_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string rendered_type = 1;</code>
+     *
+     * <pre>
+     * TODO: stub
+     * </pre>
+     */
+    public org.jetbrains.kotlin.protobuf.ByteString
+        getRenderedTypeBytes() {
+      java.lang.Object ref = renderedType_;
+      if (ref instanceof java.lang.String) {
+        org.jetbrains.kotlin.protobuf.ByteString b = 
+            org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        renderedType_ = b;
+        return b;
+      } else {
+        return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      renderedType_ = "";
+    }
+    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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getRenderedTypeBytes());
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeBytesSize(1, getRenderedTypeBytes());
+      }
+      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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.TypeOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        renderedType_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.renderedType_ = renderedType_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type.getDefaultInstance()) return this;
+        if (other.hasRenderedType()) {
+          bitField0_ |= 0x00000001;
+          renderedType_ = other.renderedType_;
+          
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.Type) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private java.lang.Object renderedType_ = "";
+      /**
+       * <code>optional string rendered_type = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public boolean hasRenderedType() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional string rendered_type = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public java.lang.String getRenderedType() {
+        java.lang.Object ref = renderedType_;
+        if (!(ref instanceof java.lang.String)) {
+          org.jetbrains.kotlin.protobuf.ByteString bs =
+              (org.jetbrains.kotlin.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          if (bs.isValidUtf8()) {
+            renderedType_ = s;
+          }
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string rendered_type = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public org.jetbrains.kotlin.protobuf.ByteString
+          getRenderedTypeBytes() {
+        java.lang.Object ref = renderedType_;
+        if (ref instanceof String) {
+          org.jetbrains.kotlin.protobuf.ByteString b = 
+              org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          renderedType_ = b;
+          return b;
+        } else {
+          return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string rendered_type = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder setRenderedType(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        renderedType_ = value;
+        
+        return this;
+      }
+      /**
+       * <code>optional string rendered_type = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder clearRenderedType() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        renderedType_ = getDefaultInstance().getRenderedType();
+        
+        return this;
+      }
+      /**
+       * <code>optional string rendered_type = 1;</code>
+       *
+       * <pre>
+       * TODO: stub
+       * </pre>
+       */
+      public Builder setRenderedTypeBytes(
+          org.jetbrains.kotlin.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        renderedType_ = value;
+        
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type)
+    }
+
+    static {
+      defaultInstance = new Type(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.Type)
+  }
+
+  public interface FileOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.cli.jvm.compiler.tmp.File)
+      org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+    /**
+     * <code>optional string relative_path = 1;</code>
+     */
+    boolean hasRelativePath();
+    /**
+     * <code>optional string relative_path = 1;</code>
+     */
+    java.lang.String getRelativePath();
+    /**
+     * <code>optional string relative_path = 1;</code>
+     */
+    org.jetbrains.kotlin.protobuf.ByteString
+        getRelativePathBytes();
+  }
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.File}
+   */
+  public static final class File extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+      // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.File)
+      FileOrBuilder {
+    // Use File.newBuilder() to construct.
+    private File(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private File(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+    private static final File defaultInstance;
+    public static File getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public File getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+    private File(
+        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: {
+              org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes();
+              bitField0_ |= 0x00000001;
+              relativePath_ = bs;
+              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 {
+        try {
+          unknownFieldsCodedOutput.flush();
+        } catch (java.io.IOException e) {
+        // Should not happen
+        } finally {
+          unknownFields = unknownFieldsOutput.toByteString();
+        }
+        makeExtensionsImmutable();
+      }
+    }
+    public static org.jetbrains.kotlin.protobuf.Parser<File> PARSER =
+        new org.jetbrains.kotlin.protobuf.AbstractParser<File>() {
+      public File parsePartialFrom(
+          org.jetbrains.kotlin.protobuf.CodedInputStream input,
+          org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+        return new File(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public org.jetbrains.kotlin.protobuf.Parser<File> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    public static final int RELATIVE_PATH_FIELD_NUMBER = 1;
+    private java.lang.Object relativePath_;
+    /**
+     * <code>optional string relative_path = 1;</code>
+     */
+    public boolean hasRelativePath() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>optional string relative_path = 1;</code>
+     */
+    public java.lang.String getRelativePath() {
+      java.lang.Object ref = relativePath_;
+      if (ref instanceof java.lang.String) {
+        return (java.lang.String) ref;
+      } else {
+        org.jetbrains.kotlin.protobuf.ByteString bs = 
+            (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        java.lang.String s = bs.toStringUtf8();
+        if (bs.isValidUtf8()) {
+          relativePath_ = s;
+        }
+        return s;
+      }
+    }
+    /**
+     * <code>optional string relative_path = 1;</code>
+     */
+    public org.jetbrains.kotlin.protobuf.ByteString
+        getRelativePathBytes() {
+      java.lang.Object ref = relativePath_;
+      if (ref instanceof java.lang.String) {
+        org.jetbrains.kotlin.protobuf.ByteString b = 
+            org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                (java.lang.String) ref);
+        relativePath_ = b;
+        return b;
+      } else {
+        return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+      }
+    }
+
+    private void initFields() {
+      relativePath_ = "";
+    }
+    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 (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, getRelativePathBytes());
+      }
+      output.writeRawBytes(unknownFields);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeBytesSize(1, getRelativePathBytes());
+      }
+      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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File parseFrom(
+        org.jetbrains.kotlin.protobuf.ByteString data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File parseFrom(byte[] data)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File parseFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File 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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    /**
+     * Protobuf type {@code org.jetbrains.kotlin.cli.jvm.compiler.tmp.File}
+     */
+    public static final class Builder extends
+        org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+          org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File, Builder>
+        implements
+        // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.cli.jvm.compiler.tmp.File)
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.FileOrBuilder {
+      // Construct using org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private void maybeForceBuilderInitialization() {
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        relativePath_ = "";
+        bitField0_ = (bitField0_ & ~0x00000001);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File getDefaultInstanceForType() {
+        return org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.getDefaultInstance();
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File build() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File buildPartial() {
+        org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File result = new org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.relativePath_ = relativePath_;
+        result.bitField0_ = to_bitField0_;
+        return result;
+      }
+
+      public Builder mergeFrom(org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File other) {
+        if (other == org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File.getDefaultInstance()) return this;
+        if (other.hasRelativePath()) {
+          bitField0_ |= 0x00000001;
+          relativePath_ = other.relativePath_;
+          
+        }
+        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.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.jetbrains.kotlin.cli.jvm.compiler.tmp.ResolutionDumpProtoBuf.File) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private java.lang.Object relativePath_ = "";
+      /**
+       * <code>optional string relative_path = 1;</code>
+       */
+      public boolean hasRelativePath() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>optional string relative_path = 1;</code>
+       */
+      public java.lang.String getRelativePath() {
+        java.lang.Object ref = relativePath_;
+        if (!(ref instanceof java.lang.String)) {
+          org.jetbrains.kotlin.protobuf.ByteString bs =
+              (org.jetbrains.kotlin.protobuf.ByteString) ref;
+          java.lang.String s = bs.toStringUtf8();
+          if (bs.isValidUtf8()) {
+            relativePath_ = s;
+          }
+          return s;
+        } else {
+          return (java.lang.String) ref;
+        }
+      }
+      /**
+       * <code>optional string relative_path = 1;</code>
+       */
+      public org.jetbrains.kotlin.protobuf.ByteString
+          getRelativePathBytes() {
+        java.lang.Object ref = relativePath_;
+        if (ref instanceof String) {
+          org.jetbrains.kotlin.protobuf.ByteString b = 
+              org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
+                  (java.lang.String) ref);
+          relativePath_ = b;
+          return b;
+        } else {
+          return (org.jetbrains.kotlin.protobuf.ByteString) ref;
+        }
+      }
+      /**
+       * <code>optional string relative_path = 1;</code>
+       */
+      public Builder setRelativePath(
+          java.lang.String value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        relativePath_ = value;
+        
+        return this;
+      }
+      /**
+       * <code>optional string relative_path = 1;</code>
+       */
+      public Builder clearRelativePath() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        relativePath_ = getDefaultInstance().getRelativePath();
+        
+        return this;
+      }
+      /**
+       * <code>optional string relative_path = 1;</code>
+       */
+      public Builder setRelativePathBytes(
+          org.jetbrains.kotlin.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        relativePath_ = value;
+        
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.File)
+    }
+
+    static {
+      defaultInstance = new File(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.cli.jvm.compiler.tmp.File)
+  }
+
+
+  static {
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpSerializer.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpSerializer.kt
new file mode 100644
index 0000000..b3f4291
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpSerializer.kt
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.impls.*
+
+interface ResolutionDumpSerializer {
+    fun serialize(dumpForFile: RDumpForFile): ByteArray
+}
+
+class ProtoBufResolutionDumpSerializer : ResolutionDumpSerializer {
+    override fun serialize(dumpForFile: RDumpForFile): ByteArray {
+        return resolutionResultsForFileProto(dumpForFile).build().toByteArray()
+    }
+
+    private fun resolutionResultsForFileProto(dumpForFile: RDumpForFile): ResolutionDumpProtoBuf.ResolutionResultForFile.Builder {
+        return ResolutionDumpProtoBuf.ResolutionResultForFile.newBuilder().apply {
+            file = ResolutionDumpProtoBuf.File.newBuilder().setRelativePath(dumpForFile.ownerFile.pathRelativeToRoot).build()
+
+            for (rDumpElement in dumpForFile.results) {
+                val elementBuilder = ResolutionDumpProtoBuf.Element.newBuilder()
+                elementBuilder.offset = rDumpElement.offset
+                elementBuilder.presentableText = rDumpElement.presentableText
+
+                when (rDumpElement) {
+                    is RDumpExpression ->
+                        elementBuilder.expression = expressionProto(rDumpElement).build()
+
+                    else -> throw IllegalStateException("Unknown Element type: $rDumpElement")
+                }
+
+                addElement(elementBuilder.build())
+            }
+        }
+    }
+
+    private fun expressionProto(expression: RDumpExpression): ResolutionDumpProtoBuf.Expression.Builder {
+        return ResolutionDumpProtoBuf.Expression.newBuilder().apply {
+            type = typeProto(expression.type).build()
+
+            when (expression) {
+                is RDumpResolvedCall -> resolved = resolvedProto(expression).build()
+                is RDumpErrorCall -> error = errorProto(expression).build()
+                else -> throw IllegalStateException("Unknown Expression type: $expression")
+            }
+        }
+    }
+
+    private fun resolvedProto(resolved: RDumpResolvedCall): ResolutionDumpProtoBuf.Resolved.Builder {
+        val candidateDescriptorProto = descriptorProto(resolved.candidateDescriptor).build()
+        val typeArgumentsProtos = resolved.typeArguments.map { typeProto(it).build() }
+
+        return ResolutionDumpProtoBuf.Resolved.newBuilder()
+            .setCandidateDescriptor(candidateDescriptorProto)
+            .addAllTypeArgument(typeArgumentsProtos)
+    }
+
+    private fun errorProto(error: RDumpErrorCall): ResolutionDumpProtoBuf.Error.Builder {
+        return ResolutionDumpProtoBuf.Error.newBuilder().apply {
+            for (diagnostic in error.diagnostics) {
+                addDiagnostic(diagnosticProto(diagnostic))
+            }
+        }
+    }
+
+    private fun diagnosticProto(rDumpDiagnostic: RDumpDiagnostic): ResolutionDumpProtoBuf.Diagnostic.Builder {
+        val textBasedRDumpDiagnostic = rDumpDiagnostic as TextBasedRDumpDiagnostic
+        return ResolutionDumpProtoBuf.Diagnostic.newBuilder().setRenderedText(textBasedRDumpDiagnostic.fullRenderedText)
+    }
+
+    private fun descriptorProto(rDumpDescriptor: RDumpDescriptor): ResolutionDumpProtoBuf.Descriptor.Builder {
+        return ResolutionDumpProtoBuf.Descriptor.newBuilder().apply {
+            fqn = (rDumpDescriptor as? TextBasedRDumpDescriptor)?.renderedDescriptor
+
+            for (typeParameterDescriptor in rDumpDescriptor.typeParameters) {
+                addTypeParameter(descriptorProto(typeParameterDescriptor).build())
+            }
+        }
+    }
+
+    private fun typeProto(rDumpType: RDumpType): ResolutionDumpProtoBuf.Type.Builder =
+        ResolutionDumpProtoBuf.Type.newBuilder().setRenderedType((rDumpType as TextBasedRDumpType).renderedType)
+}
\ No newline at end of file
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumper.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumper.kt
new file mode 100644
index 0000000..5fb0b33
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumper.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp
+
+import java.io.File
+
+interface ResolutionDumper {
+    fun dumpResolutionResult(dumpForFile: RDumpForFile)
+}
+
+class ResolutionDumperImpl(private val serializer: ResolutionDumpSerializer, private val root: File) : ResolutionDumper {
+    override fun dumpResolutionResult(dumpForFile: RDumpForFile) {
+        val destinationFile = File(root, dumpForFile.ownerFile.pathRelativeToRoot)
+        if (destinationFile.exists()) {
+            destinationFile.delete()
+        }
+
+        destinationFile.createNewFile()
+
+        val serializedResolutionResult = serializer.serialize(dumpForFile)
+
+        destinationFile.outputStream().use {
+            it.write(serializedResolutionResult)
+        }
+    }
+}
\ No newline at end of file
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpsComparator.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpsComparator.kt
new file mode 100644
index 0000000..aaeb725
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionDumpsComparator.kt
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.impls.RDumpErrorCall
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.impls.RDumpResolvedCall
+import org.jetbrains.kotlin.utils.addIfNotNull
+
+class ResolutionDumpsComparator {
+    fun compareDumpsForFile(before: RDumpForFile, after: RDumpForFile) {
+        check(before.ownerFile == after.ownerFile) { "Trying to compare dumps for different files" }
+
+        val offsetToElementMapBefore = before.results.associateBy { it.offset }
+        val offsetToElementMapAfter = after.results.associateBy { it.offset }
+
+        val allOffsets = offsetToElementMapBefore.keys union offsetToElementMapAfter.keys
+
+        val diff: MutableList<ResolutionDifference> = mutableListOf()
+        for (offset in allOffsets) {
+            val elementBefore = offsetToElementMapBefore[offset]
+            val elementAfter = offsetToElementMapAfter[offset]
+
+            val difference = when {
+                elementBefore != null && elementAfter == null ->
+                    ResolutionDifference(elementBefore.presentableText, MissingInDump(elementBefore, elementAfter))
+
+                elementBefore == null && elementAfter != null ->
+                    ResolutionDifference(elementAfter.presentableText, MissingInDump(elementBefore, elementAfter))
+
+                elementBefore != null && elementAfter != null -> compareResolutionElements(elementBefore, elementAfter)
+
+                else -> throw IllegalStateException("No elements at offset $offset")
+            }
+
+            diff.addIfNotNull(difference)
+        }
+    }
+
+    private fun compareResolutionElements(before: RDumpElement, after: RDumpElement): ResolutionDifference? {
+        check(before.presentableText == after.presentableText) {
+            "Elements at the same offsets in the same file have different presentable texts:\n" +
+                    "   First: $before\n" +
+                    "   Second: $after"
+        }
+
+        if (before::class != after::class) {
+            return ResolutionDifference(before.presentableText, ResolutionStatusMismatch(before, after))
+        }
+
+        return when {
+            before is RDumpExpression && after is RDumpExpression -> compareExpressions(before, after)
+            else -> throw IllegalStateException("Unknown Element type: $before")
+        }
+    }
+
+    private fun compareExpressions(before: RDumpExpression, after: RDumpExpression): ResolutionDifference? {
+        return when {
+            before is RDumpResolvedCall && after is RDumpResolvedCall -> compareResolved(before, after)
+            before is RDumpErrorCall && after is RDumpErrorCall -> compareErrorCalls(before, after)
+            else -> throw IllegalStateException("Unknown Expression type: $before")
+        }
+    }
+
+    private fun compareErrorCalls(before: RDumpErrorCall, after: RDumpErrorCall): ResolutionDifference? {
+        val diagnosticsSetBefore = before.diagnostics.toSet()
+        val diagnosticsSetAfter = after.diagnostics.toSet()
+
+        val allDiagnostics = diagnosticsSetBefore union diagnosticsSetAfter
+
+        val mismatchedDiagnostics: MutableList<DiagnosticsMismatch.MismatchedDiagnostic> = mutableListOf()
+        iterateOverDiagnostics@ for (diagnostic in allDiagnostics) {
+            when {
+                diagnostic in diagnosticsSetBefore && diagnostic in diagnosticsSetAfter ->
+                    continue@iterateOverDiagnostics
+
+                diagnostic in diagnosticsSetBefore && diagnostic !in diagnosticsSetAfter ->
+                    mismatchedDiagnostics += DiagnosticsMismatch.LostDiagnostic(diagnostic)
+
+                diagnostic !in diagnosticsSetBefore && diagnostic in diagnosticsSetAfter ->
+                    mismatchedDiagnostics += DiagnosticsMismatch.NewDiagnostic(diagnostic)
+
+                else -> throw IllegalStateException()
+            }
+        }
+
+        return if (mismatchedDiagnostics.isNotEmpty())
+            ResolutionDifference(before.presentableText, DiagnosticsMismatch(mismatchedDiagnostics))
+        else
+            null
+    }
+
+    private fun compareResolved(before: RDumpResolvedCall, after: RDumpResolvedCall): ResolutionDifference? {
+        if (before.candidateDescriptor != after.candidateDescriptor) {
+            return ResolutionDifference(
+                before.presentableText,
+                CandidateDescriptorMismatch(before.candidateDescriptor, after.candidateDescriptor)
+            )
+        }
+
+        val typeParameterDifferences: MutableList<InferenceMismatch.TypeParameterInference> = mutableListOf()
+        for (i in before.candidateDescriptor.typeParameters.indices) {
+            val typeParameterBefore = before.candidateDescriptor.typeParameters[i]
+            val typeParameterAfter = after.candidateDescriptor.typeParameters[i]
+            check(typeParameterBefore == typeParameterAfter) {
+                "Type parameters in candidate descriptors are not the same: for index $i before was $typeParameterBefore, after became $typeParameterAfter"
+            }
+
+            val typeArgumentBefore = before.typeArguments[i]
+            val typeArgumentAfter = after.typeArguments[i]
+
+            if (typeArgumentBefore != typeArgumentAfter) {
+                typeParameterDifferences.add(
+                    InferenceMismatch.TypeParameterInference(
+                        typeParameterBefore,
+                        typeArgumentBefore,
+                        typeArgumentAfter
+                    )
+                )
+            }
+        }
+
+        return if (typeParameterDifferences.isNotEmpty())
+            ResolutionDifference(before.presentableText, InferenceMismatch(typeParameterDifferences))
+        else
+            null
+    }
+
+}
+
+
+class ResolutionDifference(val elementText: String, val reason: MismatchReason) {
+    fun render(): String =
+        "Resolution mismatch for $elementText\n" + reason.reasonText
+}
+
+
+sealed class MismatchReason(val reasonText: String)
+
+class MissingInDump(before: RDumpElement?, after: RDumpElement?) :
+    MismatchReason(
+        "Missing resolution result in one of the dumps:\n" +
+                "    Was: ${before ?: "<ABSENT>"}\n" +
+                "    Become: ${after ?: "<ABSENT>"}\n"
+    )
+
+class CandidateDescriptorMismatch(beforeDescriptor: RDumpDescriptor, afterDescriptor: RDumpDescriptor) :
+    MismatchReason(
+        "Candidate descriptor have changed:\n" +
+                "   Was: $beforeDescriptor\n" +
+                "   Become: $afterDescriptor"
+    )
+
+class InferenceMismatch(val mismatchedTypeParameters: List<TypeParameterInference>) :
+    MismatchReason(
+        "Inference for type parameter(s) have changed:\n" +
+                mismatchedTypeParameters.joinToString(separator = "\n\n")
+    ) {
+
+    data class TypeParameterInference(val typeParameterDescriptor: RDumpDescriptor, val before: RDumpType, val after: RDumpType) {
+        override fun toString(): String = "Type parameter: $typeParameterDescriptor\n" +
+                "Was: $before\n" +
+                "Become: $after"
+    }
+}
+
+
+// E.g. Resolved -> Error
+class ResolutionStatusMismatch(before: RDumpElement, after: RDumpElement) :
+    MismatchReason(
+        "Resolution kind have changed:" +
+                "   Was: $before\n" +
+                "   After: $after"
+    )
+
+class DiagnosticsMismatch(mismatchedDiagnostics: List<MismatchedDiagnostic>) :
+    MismatchReason("Diagnostics are different:\n" + mismatchedDiagnostics.joinToString(separator = "\n")) {
+
+    interface MismatchedDiagnostic
+
+    class NewDiagnostic(val diagnostic: RDumpDiagnostic) : MismatchedDiagnostic {
+        override fun toString(): String = "Appeared new diagnostic: \"$diagnostic\""
+    }
+
+    class LostDiagnostic(val diagnostic: RDumpDiagnostic) : MismatchedDiagnostic {
+        override fun toString(): String = "Missing diagnostic: \"$diagnostic\""
+    }
+}
+
+
+
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionResults.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionResults.kt
new file mode 100644
index 0000000..97a46b7
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/ResolutionResults.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp
+
+class RDumpForFile(val ownerFile: RDumpFile, val results: List<RDumpElement>)
+
+
+// ====== Hierarchy ==========
+
+interface RDumpElement {
+    val offset: Int
+    val presentableText: String
+}
+
+interface RDumpExpression : RDumpElement {
+    val type: RDumpType
+}
+
+
+// ======== Utility =============
+
+interface RDumpFile {
+    val pathRelativeToRoot: String
+
+    fun getLineNumberByOffset(offset: Int): Int
+    fun getColumnNumberByOffset(offset: Int): Int
+}
+
+// TODO: full descriptor?
+interface RDumpDescriptor {
+    val typeParameters: List<RDumpDescriptor>
+}
+
+// TODO: full type?
+interface RDumpType
+
+// TODO: full diagnostic?
+interface RDumpDiagnostic
\ No newline at end of file
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/ResolutionDumpImpls.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/ResolutionDumpImpls.kt
new file mode 100644
index 0000000..47a434b
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/ResolutionDumpImpls.kt
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp.impls
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.*
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.psiUtil.startOffset
+
+// Equality expected to work correctly only with elements from the same file
+abstract class AbstractRDumpElement(override val offset: Int, override val presentableText: String) : RDumpElement {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as AbstractRDumpElement
+
+        if (offset != other.offset) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int = offset
+
+    override fun toString(): String = presentableText
+}
+
+abstract class AbstractRDumpExpression(offset: Int, presentableText: String, override val type: RDumpType) :
+    AbstractRDumpElement(offset, presentableText), RDumpExpression
+
+class RDumpResolvedCall(
+    offset: Int,
+    presentableText: String,
+    type: RDumpType,
+    val candidateDescriptor: RDumpDescriptor,
+    val typeArguments: List<RDumpType>
+) : AbstractRDumpExpression(offset, presentableText, type) {
+
+    constructor(
+        original: KtElement,
+        type: RDumpType,
+        candidateDescriptor: RDumpDescriptor,
+        typeArguments: List<RDumpType>
+    ) : this(original.startOffset, original.text, type, candidateDescriptor, typeArguments)
+}
+
+class RDumpErrorCall(offset: Int, presentableText: String, val diagnostics: List<RDumpDiagnostic>) :
+    AbstractRDumpExpression(offset, presentableText, RDumpErrorType) {
+
+    constructor(
+        original: KtElement,
+        vararg diagnostics: RDumpDiagnostic
+    ) : this(original.startOffset, original.text, diagnostics.toList())
+}
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/TextBasedStubs.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/TextBasedStubs.kt
new file mode 100644
index 0000000..50f0d19
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/TextBasedStubs.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp.impls
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.NativeElementsFactory
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.RDumpDescriptor
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.RDumpDiagnostic
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.RDumpType
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.types.KotlinType
+
+open class TextBasedRDumpType(val renderedType: String) : RDumpType
+object RDumpErrorType : TextBasedRDumpType("ERROR_TYPE")
+
+open class TextBasedRDumpDescriptor(val renderedDescriptor: String, override val typeParameters: List<RDumpDescriptor>) : RDumpDescriptor
+
+class TextBasedRDumpDiagnostic(val diagnosticFamily: String, val fullRenderedText: String) : RDumpDiagnostic
+
+object TextBasedNativeElementsFactory : NativeElementsFactory {
+    override fun convertToRDumpDescriptor(descriptor: DeclarationDescriptor): RDumpDescriptor {
+        val typeParameters = (descriptor as? CallableDescriptor)?.typeParameters?.map { convertToRDumpDescriptor(it) } ?: emptyList()
+        return TextBasedRDumpDescriptor(renderDescriptor(descriptor), typeParameters)
+    }
+
+    override fun convertToRDumpType(type: KotlinType): RDumpType {
+        return TextBasedRDumpType(renderType(type))
+    }
+
+    override fun convertToRDumpDiagnostic(diagnostic: Diagnostic): RDumpDiagnostic {
+        return TextBasedRDumpDiagnostic(
+            diagnosticFamily = diagnostic.factory.name,
+            fullRenderedText = renderDiagnostic(diagnostic)
+        )
+    }
+
+    private fun renderDescriptor(descriptor: DeclarationDescriptor): String {
+        return DescriptorRenderer.DEBUG_TEXT.render(descriptor)
+    }
+
+    private fun renderType(type: KotlinType): String {
+        return DescriptorRenderer.DEBUG_TEXT.renderType(type)
+    }
+
+    private fun renderDiagnostic(diagnostic: Diagnostic): String {
+        return DefaultErrorMessages.render(diagnostic)
+    }
+}
\ No newline at end of file
diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/VirtualFileBasedRDumpFile.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/VirtualFileBasedRDumpFile.kt
new file mode 100644
index 0000000..932ceb1
--- /dev/null
+++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/tmp/impls/VirtualFileBasedRDumpFile.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.cli.jvm.compiler.tmp.impls
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.RDumpFile
+import java.io.File
+
+class FileBasedRDumpFile(val file: File, override val pathRelativeToRoot: String) : RDumpFile {
+    override fun getLineNumberByOffset(offset: Int): Int {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun getColumnNumberByOffset(offset: Int): Int {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as FileBasedRDumpFile
+
+        if (pathRelativeToRoot != other.pathRelativeToRoot) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        return pathRelativeToRoot.hashCode()
+    }
+}
\ No newline at end of file
diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractResolutionDumpTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractResolutionDumpTest.kt
new file mode 100644
index 0000000..75e5355
--- /dev/null
+++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractResolutionDumpTest.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.codegen
+
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.IrBasedResolutionDumpBuilder
+import org.jetbrains.kotlin.cli.jvm.compiler.tmp.impls.TextBasedNativeElementsFactory
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.ir.AbstractIrGeneratorTestCase
+import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
+import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
+import org.jetbrains.kotlin.psi2ir.generators.GeneratorContext
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
+import java.io.File
+
+class AbstractResolutionDumpTest : AbstractIrGeneratorTestCase() {
+    override fun doTest(wholeFile: File, testFiles: List<TestFile>) {
+        val (bindingContext, moduleDescriptor, _) = JvmResolveUtil.analyze(myFiles.psiFiles, myEnvironment)
+        val generatorContext = GeneratorContext(Psi2IrConfiguration(ignoreErrors = true), moduleDescriptor, bindingContext)
+        val psi2ir = Psi2IrTranslator(LanguageVersionSettingsImpl.DEFAULT)
+        val builder = IrBasedResolutionDumpBuilder(bindingContext, TextBasedNativeElementsFactory, File(""))
+
+        val moduleFragment = psi2ir.generateModuleFragment(generatorContext, myFiles.psiFiles)
+
+        for (irFile in moduleFragment.files) {
+            val physicalFile = File(irFile.fileEntry.name)
+            builder.buildResolutionDumpForFile(irFile, physicalFile)
+        }
+    }
+}
\ No newline at end of file