Implement stub building for inner types

core/descriptors/src/org/jetbrains/kotlin/descriptors/typeParameterUtils.kt

@@ -16,8 +16,9 @@
 
 package org.jetbrains.kotlin.descriptors
 
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.TypeProjection
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.error.MissingDependencyErrorClass
+import java.util.*
 
 fun ClassDescriptor.computeConstructorTypeParameters(): List<TypeParameterDescriptor> {
     val declaredParameters = declaredTypeParameters
@@ -55,8 +56,13 @@ class PossiblyInnerType(
     fun segments(): List<PossiblyInnerType> = outerType?.segments().orEmpty() + this
 }
 
-fun KotlinType.buildPossiblyInnerType(): PossiblyInnerType?
-        = buildPossiblyInnerType(constructor.declarationDescriptor as? ClassDescriptor, 0)
+fun KotlinType.buildPossiblyInnerType(): PossiblyInnerType? {
+    if (constructor.declarationDescriptor is MissingDependencyErrorClass) {
+        return getCapability<PossiblyInnerTypeCapability>()?.possiblyInnerType
+    }
+
+    return buildPossiblyInnerType(constructor.declarationDescriptor as? ClassDescriptor, 0)
+}
 
 private fun KotlinType.buildPossiblyInnerType(classDescriptor: ClassDescriptor?, index: Int): PossiblyInnerType? {
     if (classDescriptor == null) return null

core/descriptors/src/org/jetbrains/kotlin/types/TypeCapabilities.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.types
 
+import org.jetbrains.kotlin.descriptors.PossiblyInnerType
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 
 public interface TypeCapability
@@ -28,6 +29,18 @@ public interface TypeCapabilities {
     fun <T : TypeCapability> getCapability(capabilityClass: Class<T>): T?
 }
 
+class CompositeTypeCapabilities(private val first: TypeCapabilities, private val second: TypeCapabilities) : TypeCapabilities {
+    override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>): T? =
+            first.getCapability(capabilityClass) ?: second.getCapability(capabilityClass)
+}
+
+class SingletonTypeCapabilities(private val clazz: Class<*>, private val typeCapability: TypeCapability) : TypeCapabilities {
+    override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>): T? {
+        if (capabilityClass == clazz) return typeCapability as T
+        return null
+    }
+}
+
 public inline fun <reified T : TypeCapability> KotlinType.getCapability(): T? = getCapability(javaClass<T>())
 
 public interface Specificity : TypeCapability {
@@ -88,3 +101,7 @@ public fun sameTypeConstructors(first: KotlinType, second: KotlinType): Boolean
 interface CustomSubstitutionCapability : TypeCapability {
     public val substitution: TypeSubstitution
 }
+
+interface PossiblyInnerTypeCapability : TypeCapability {
+    public val possiblyInnerType: PossiblyInnerType?
+}

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializedType.kt

@@ -16,6 +16,8 @@
 
 package org.jetbrains.kotlin.serialization.deserialization
 
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.PossiblyInnerType
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.serialization.ProtoBuf
@@ -58,7 +60,34 @@ class DeserializedType(
 
     override fun getAnnotations(): Annotations = annotations
 
-    override fun getCapabilities() = c.components.typeCapabilitiesLoader.loadCapabilities(typeProto)
+    override fun getCapabilities() = typeCapabilities()
+
+    private val typeCapabilities = c.storageManager.createLazyValue { computeCapabilities() }
+
+    private fun computeCapabilities(): TypeCapabilities {
+        val capabilities = c.components.typeCapabilitiesLoader.loadCapabilities(typeProto)
+
+        return computePossiblyInnerType()?.let { it: PossiblyInnerType ->
+            CompositeTypeCapabilities(
+                    SingletonTypeCapabilities(
+                            PossiblyInnerTypeCapability::class.java,
+                            PossiblyInnerTypeCapabilityImpl(it)),
+                    capabilities)
+        } ?: capabilities
+    }
+
+    private fun computePossiblyInnerType(): PossiblyInnerType? {
+        if (!typeProto.hasClassName()) return null
+
+        val outerType = typeProto.outerType(c.typeTable)?.let { DeserializedType(c, it).computePossiblyInnerType() }
+
+        return PossiblyInnerType(
+                constructor.declarationDescriptor as ClassDescriptor,
+                typeProto.argumentList.deserialize(),
+                outerType)
+    }
+
+    private class PossiblyInnerTypeCapabilityImpl(override val possiblyInnerType: PossiblyInnerType?) : PossiblyInnerTypeCapability
 
     fun getPresentableText(): String = typeDeserializer.presentableTextForErrorType(typeProto)
 }