[KLIB] Support DefinitelyNotNull type in KLIB

- add proto message
 - serialize/deserialize

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/DeepCopyIrTreeWithSymbolsForFakeOverrides.kt

@@ -50,22 +50,19 @@ class DeepCopyIrTreeWithSymbolsForFakeOverrides(typeArguments: Map<IrTypeParamet
         override fun remapType(type: IrType): IrType {
             if (type !is IrSimpleType) return type
 
-            val substitutedType = typeArguments[type.classifier]
+            return when (val substitutedType = typeArguments[type.classifier]) {
-
+                is IrDynamicType -> substitutedType
-            if (substitutedType is IrDynamicType) return substitutedType
+                is IrDefinitelyNotNullType -> substitutedType
-
+                is IrSimpleType -> substitutedType.buildSimpleType {
-            if (substitutedType is IrSimpleType) {
-                return substitutedType.buildSimpleType {
                     kotlinType = null
                     hasQuestionMark = type.hasQuestionMark or substitutedType.isMarkedNullable()
                 }
-            }
+                else -> type.buildSimpleType {
-
+                    kotlinType = null
-            return type.buildSimpleType {
+                    classifier = symbolRemapper.getReferencedClassifier(type.classifier)
-                kotlinType = null
+                    arguments = remapTypeArguments(type.arguments)
-                classifier = symbolRemapper.getReferencedClassifier(type.classifier)
+                    annotations = type.annotations.map { it.transform(copier, null) as IrConstructorCall }
-                arguments = remapTypeArguments(type.arguments)
+                }
-                annotations = type.annotations.map { it.transform(copier, null) as IrConstructorCall }
             }
         }
     }

compiler/ir/serialization.common/src/KotlinIr.proto

@@ -109,6 +109,11 @@ message IrDynamicType {
   repeated IrConstructorCall annotation = 1;
 }
 
+message IrDefinitelyNotNullType {
+  // In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+  repeated int32 types = 1 [packed=true];
+}
+
 message IrErrorType {
   repeated IrConstructorCall annotation = 1;
 }
@@ -118,6 +123,7 @@ message IrType {
     IrSimpleType simple = 1;
     IrDynamicType dynamic = 2;
     IrErrorType error = 3;
+    IrDefinitelyNotNullType dnn = 4;
   }
 }
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructor as
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructorCall as ProtoConstructorCall
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclaration as ProtoDeclaration
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase as ProtoDeclarationBase
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType as ProtoDefinitelyNotNullType
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDynamicType as ProtoDynamicType
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrEnumEntry as ProtoEnumEntry
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration as ProtoErrorDeclaration
@@ -155,8 +156,15 @@ class IrDeclarationDeserializer(
         return IrErrorTypeImpl(null, annotations, Variance.INVARIANT)
     }
 
+    private fun deserializeDefinitelyNotNullType(proto: ProtoDefinitelyNotNullType): IrDefinitelyNotNullType {
+        assert(proto.typesCount == 1) { "Only DefinitelyNotNull type is now supported" }
+        // TODO support general case of intersection type
+        return IrDefinitelyNotNullTypeImpl(null, deserializeIrType(proto.typesList[0]))
+    }
+
     private fun deserializeIrTypeData(proto: ProtoType): IrType {
         return when (proto.kindCase) {
+            DNN -> deserializeDefinitelyNotNullType(proto.dnn)
             SIMPLE -> deserializeSimpleType(proto.simple)
             DYNAMIC -> deserializeDynamicType(proto.dynamic)
             ERROR -> deserializeErrorType(proto.error)

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt

@@ -54,6 +54,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructorCall
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrContinue as ProtoContinue
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclaration as ProtoDeclaration
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase as ProtoDeclarationBase
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType as ProtoDefinitelyNotNullType
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDelegatingConstructorCall as ProtoDelegatingConstructorCall
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDoWhile as ProtoDoWhile
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDynamicMemberExpression as ProtoDynamicMemberExpression
@@ -437,9 +438,17 @@ open class IrFileSerializer(
         .addAllAnnotation(serializeAnnotations(type.annotations))
         .build()
 
+    private fun serializeDefinitelyNotNullType(type: IrDefinitelyNotNullType): ProtoDefinitelyNotNullType =
+        ProtoDefinitelyNotNullType.newBuilder()
+            .addTypes(serializeIrType(type.original))
+//            .addTypes(serializeIrType(kotlin.Any))
+            .build()
+
     private fun serializeIrTypeData(type: IrType): ProtoType {
         val proto = ProtoType.newBuilder()
         when (type) {
+            is IrDefinitelyNotNullType ->
+                proto.dnn = serializeDefinitelyNotNullType(type)
             is IrSimpleType ->
                 proto.simple = serializeSimpleType(type)
             is IrDynamicType ->
@@ -454,7 +463,8 @@ open class IrFileSerializer(
     enum class IrTypeKind {
         SIMPLE,
         DYNAMIC,
-        ERROR
+        ERROR,
+        DEFINITELY_NOT_NULL
     }
 
     enum class IrTypeArgumentKind {
@@ -481,6 +491,7 @@ open class IrFileSerializer(
     private val IrType.toIrTypeKey: IrTypeKey
         get() = IrTypeKey(
             kind = when (this) {
+                is IrDefinitelyNotNullType -> IrTypeKind.DEFINITELY_NOT_NULL
                 is IrSimpleType -> IrTypeKind.SIMPLE
                 is IrDynamicType -> IrTypeKind.DYNAMIC
                 is IrErrorType -> IrTypeKind.ERROR

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrDefinitelyNotNullType.java

@@ -0,0 +1,468 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: compiler/ir/serialization.common/src/KotlinIr.proto
+
+package org.jetbrains.kotlin.backend.common.serialization.proto;
+
+/**
+ * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType}
+ */
+public final class IrDefinitelyNotNullType extends
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+    // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType)
+    IrDefinitelyNotNullTypeOrBuilder {
+  // Use IrDefinitelyNotNullType.newBuilder() to construct.
+  private IrDefinitelyNotNullType(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+    super(builder);
+    this.unknownFields = builder.getUnknownFields();
+  }
+  private IrDefinitelyNotNullType(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+  private static final IrDefinitelyNotNullType defaultInstance;
+  public static IrDefinitelyNotNullType getDefaultInstance() {
+    return defaultInstance;
+  }
+
+  public IrDefinitelyNotNullType getDefaultInstanceForType() {
+    return defaultInstance;
+  }
+
+  private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  private IrDefinitelyNotNullType(
+      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, 1);
+    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: {
+            if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+              types_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000001;
+            }
+            types_.add(input.readInt32());
+            break;
+          }
+          case 10: {
+            int length = input.readRawVarint32();
+            int limit = input.pushLimit(length);
+            if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
+              types_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000001;
+            }
+            while (input.getBytesUntilLimit() > 0) {
+              types_.add(input.readInt32());
+            }
+            input.popLimit(limit);
+            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)) {
+        types_ = java.util.Collections.unmodifiableList(types_);
+      }
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+  public static org.jetbrains.kotlin.protobuf.Parser<IrDefinitelyNotNullType> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<IrDefinitelyNotNullType>() {
+    public IrDefinitelyNotNullType parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new IrDefinitelyNotNullType(input, extensionRegistry);
+    }
+  };
+
+  @java.lang.Override
+  public org.jetbrains.kotlin.protobuf.Parser<IrDefinitelyNotNullType> getParserForType() {
+    return PARSER;
+  }
+
+  public static final int TYPES_FIELD_NUMBER = 1;
+  private java.util.List<java.lang.Integer> types_;
+  /**
+   * <code>repeated int32 types = 1 [packed = true];</code>
+   *
+   * <pre>
+   * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+   * </pre>
+   */
+  public java.util.List<java.lang.Integer>
+      getTypesList() {
+    return types_;
+  }
+  /**
+   * <code>repeated int32 types = 1 [packed = true];</code>
+   *
+   * <pre>
+   * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+   * </pre>
+   */
+  public int getTypesCount() {
+    return types_.size();
+  }
+  /**
+   * <code>repeated int32 types = 1 [packed = true];</code>
+   *
+   * <pre>
+   * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+   * </pre>
+   */
+  public int getTypes(int index) {
+    return types_.get(index);
+  }
+  private int typesMemoizedSerializedSize = -1;
+
+  private void initFields() {
+    types_ = 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 (getTypesList().size() > 0) {
+      output.writeRawVarint32(10);
+      output.writeRawVarint32(typesMemoizedSerializedSize);
+    }
+    for (int i = 0; i < types_.size(); i++) {
+      output.writeInt32NoTag(types_.get(i));
+    }
+    output.writeRawBytes(unknownFields);
+  }
+
+  private int memoizedSerializedSize = -1;
+  public int getSerializedSize() {
+    int size = memoizedSerializedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    {
+      int dataSize = 0;
+      for (int i = 0; i < types_.size(); i++) {
+        dataSize += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeInt32SizeNoTag(types_.get(i));
+      }
+      size += dataSize;
+      if (!getTypesList().isEmpty()) {
+        size += 1;
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+            .computeInt32SizeNoTag(dataSize);
+      }
+      typesMemoizedSerializedSize = dataSize;
+    }
+    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.backend.common.serialization.proto.IrDefinitelyNotNullType parseFrom(
+      org.jetbrains.kotlin.protobuf.ByteString data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType 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.backend.common.serialization.proto.IrDefinitelyNotNullType parseFrom(byte[] data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType 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.backend.common.serialization.proto.IrDefinitelyNotNullType parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType 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.backend.common.serialization.proto.IrDefinitelyNotNullType parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType 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.backend.common.serialization.proto.IrDefinitelyNotNullType parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType 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.backend.common.serialization.proto.IrDefinitelyNotNullType prototype) {
+    return newBuilder().mergeFrom(prototype);
+  }
+  public Builder toBuilder() { return newBuilder(this); }
+
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType}
+   */
+  public static final class Builder extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType, Builder>
+      implements
+      // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType)
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullTypeOrBuilder {
+    // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private void maybeForceBuilderInitialization() {
+    }
+    private static Builder create() {
+      return new Builder();
+    }
+
+    public Builder clear() {
+      super.clear();
+      types_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000001);
+      return this;
+    }
+
+    public Builder clone() {
+      return create().mergeFrom(buildPartial());
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType getDefaultInstanceForType() {
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.getDefaultInstance();
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType build() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType(this);
+      int from_bitField0_ = bitField0_;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        types_ = java.util.Collections.unmodifiableList(types_);
+        bitField0_ = (bitField0_ & ~0x00000001);
+      }
+      result.types_ = types_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.getDefaultInstance()) return this;
+      if (!other.types_.isEmpty()) {
+        if (types_.isEmpty()) {
+          types_ = other.types_;
+          bitField0_ = (bitField0_ & ~0x00000001);
+        } else {
+          ensureTypesIsMutable();
+          types_.addAll(other.types_);
+        }
+        
+      }
+      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.backend.common.serialization.proto.IrDefinitelyNotNullType parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) e.getUnfinishedMessage();
+        throw e;
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+    private int bitField0_;
+
+    private java.util.List<java.lang.Integer> types_ = java.util.Collections.emptyList();
+    private void ensureTypesIsMutable() {
+      if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+        types_ = new java.util.ArrayList<java.lang.Integer>(types_);
+        bitField0_ |= 0x00000001;
+       }
+    }
+    /**
+     * <code>repeated int32 types = 1 [packed = true];</code>
+     *
+     * <pre>
+     * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+     * </pre>
+     */
+    public java.util.List<java.lang.Integer>
+        getTypesList() {
+      return java.util.Collections.unmodifiableList(types_);
+    }
+    /**
+     * <code>repeated int32 types = 1 [packed = true];</code>
+     *
+     * <pre>
+     * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+     * </pre>
+     */
+    public int getTypesCount() {
+      return types_.size();
+    }
+    /**
+     * <code>repeated int32 types = 1 [packed = true];</code>
+     *
+     * <pre>
+     * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+     * </pre>
+     */
+    public int getTypes(int index) {
+      return types_.get(index);
+    }
+    /**
+     * <code>repeated int32 types = 1 [packed = true];</code>
+     *
+     * <pre>
+     * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+     * </pre>
+     */
+    public Builder setTypes(
+        int index, int value) {
+      ensureTypesIsMutable();
+      types_.set(index, value);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 types = 1 [packed = true];</code>
+     *
+     * <pre>
+     * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+     * </pre>
+     */
+    public Builder addTypes(int value) {
+      ensureTypesIsMutable();
+      types_.add(value);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 types = 1 [packed = true];</code>
+     *
+     * <pre>
+     * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+     * </pre>
+     */
+    public Builder addAllTypes(
+        java.lang.Iterable<? extends java.lang.Integer> values) {
+      ensureTypesIsMutable();
+      org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+          values, types_);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 types = 1 [packed = true];</code>
+     *
+     * <pre>
+     * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+     * </pre>
+     */
+    public Builder clearTypes() {
+      types_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000001);
+      
+      return this;
+    }
+
+    // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType)
+  }
+
+  static {
+    defaultInstance = new IrDefinitelyNotNullType(true);
+    defaultInstance.initFields();
+  }
+
+  // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType)
+}

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrDefinitelyNotNullTypeOrBuilder.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: compiler/ir/serialization.common/src/KotlinIr.proto
+
+package org.jetbrains.kotlin.backend.common.serialization.proto;
+
+public interface IrDefinitelyNotNullTypeOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType)
+    org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+  /**
+   * <code>repeated int32 types = 1 [packed = true];</code>
+   *
+   * <pre>
+   * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+   * </pre>
+   */
+  java.util.List<java.lang.Integer> getTypesList();
+  /**
+   * <code>repeated int32 types = 1 [packed = true];</code>
+   *
+   * <pre>
+   * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+   * </pre>
+   */
+  int getTypesCount();
+  /**
+   * <code>repeated int32 types = 1 [packed = true];</code>
+   *
+   * <pre>
+   * In fact that is an `IntersectionType` so let represent it as it. In future it could be easy to support general case
+   * </pre>
+   */
+  int getTypes(int index);
+}

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrType.java

@@ -92,6 +92,19 @@ public final class IrType extends
             kindCase_ = 3;
             break;
           }
+          case 34: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.Builder subBuilder = null;
+            if (kindCase_ == 4) {
+              subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) kind_).toBuilder();
+            }
+            kind_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) kind_);
+              kind_ = subBuilder.buildPartial();
+            }
+            kindCase_ = 4;
+            break;
+          }
         }
       }
     } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -133,6 +146,7 @@ public final class IrType extends
     SIMPLE(1),
     DYNAMIC(2),
     ERROR(3),
+    DNN(4),
     KIND_NOT_SET(0);
     private int value = 0;
     private KindCase(int value) {
@@ -143,6 +157,7 @@ public final class IrType extends
         case 1: return SIMPLE;
         case 2: return DYNAMIC;
         case 3: return ERROR;
+        case 4: return DNN;
         case 0: return KIND_NOT_SET;
         default: throw new java.lang.IllegalArgumentException(
           "Value is undefined for this oneof enum.");
@@ -210,6 +225,23 @@ public final class IrType extends
     return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorType.getDefaultInstance();
   }
 
+  public static final int DNN_FIELD_NUMBER = 4;
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+   */
+  public boolean hasDnn() {
+    return kindCase_ == 4;
+  }
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType getDnn() {
+    if (kindCase_ == 4) {
+       return (org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) kind_;
+    }
+    return org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.getDefaultInstance();
+  }
+
   private void initFields() {
   }
   private byte memoizedIsInitialized = -1;
@@ -252,6 +284,9 @@ public final class IrType extends
     if (kindCase_ == 3) {
       output.writeMessage(3, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorType) kind_);
     }
+    if (kindCase_ == 4) {
+      output.writeMessage(4, (org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) kind_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -273,6 +308,10 @@ public final class IrType extends
       size += org.jetbrains.kotlin.protobuf.CodedOutputStream
         .computeMessageSize(3, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorType) kind_);
     }
+    if (kindCase_ == 4) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(4, (org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) kind_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -401,6 +440,9 @@ public final class IrType extends
       if (kindCase_ == 3) {
         result.kind_ = kind_;
       }
+      if (kindCase_ == 4) {
+        result.kind_ = kind_;
+      }
       result.bitField0_ = to_bitField0_;
       result.kindCase_ = kindCase_;
       return result;
@@ -421,6 +463,10 @@ public final class IrType extends
           mergeError(other.getError());
           break;
         }
+        case DNN: {
+          mergeDnn(other.getDnn());
+          break;
+        }
         case KIND_NOT_SET: {
           break;
         }
@@ -677,6 +723,70 @@ public final class IrType extends
       return this;
     }
 
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+     */
+    public boolean hasDnn() {
+      return kindCase_ == 4;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType getDnn() {
+      if (kindCase_ == 4) {
+        return (org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) kind_;
+      }
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.getDefaultInstance();
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+     */
+    public Builder setDnn(org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      kind_ = value;
+
+      kindCase_ = 4;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+     */
+    public Builder setDnn(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.Builder builderForValue) {
+      kind_ = builderForValue.build();
+
+      kindCase_ = 4;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+     */
+    public Builder mergeDnn(org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType value) {
+      if (kindCase_ == 4 &&
+          kind_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.getDefaultInstance()) {
+        kind_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType.newBuilder((org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType) kind_)
+            .mergeFrom(value).buildPartial();
+      } else {
+        kind_ = value;
+      }
+
+      kindCase_ = 4;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+     */
+    public Builder clearDnn() {
+      if (kindCase_ == 4) {
+        kindCase_ = 0;
+        kind_ = null;
+        
+      }
+      return this;
+    }
+
     // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrType)
   }
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrTypeOrBuilder.java

@@ -33,4 +33,13 @@ public interface IrTypeOrBuilder extends
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorType error = 3;</code>
    */
   org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorType getError();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+   */
+  boolean hasDnn();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType dnn = 4;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType getDnn();
 }