From 26ede5d885b08df94b2a915811ac8e4ae9ac1326 Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Fri, 13 Aug 2021 09:09:29 +0200
Subject: [PATCH] [Commonizer] Add small documentation on CirSupertypesResolver

^KT-47430
---
 .../commonizer/cir/CirSupertypesResolver.kt   | 30 +++++++++++--------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt b/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt
index 54c481ed450..1e63b0c95fd 100644
--- a/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt
+++ b/native/commonizer/src/org/jetbrains/kotlin/commonizer/cir/CirSupertypesResolver.kt
@@ -9,17 +9,21 @@ import org.jetbrains.kotlin.commonizer.mergedtree.CirClassifierIndex
 import org.jetbrains.kotlin.commonizer.mergedtree.CirProvided
 import org.jetbrains.kotlin.commonizer.mergedtree.CirProvidedClassifiers
 import org.jetbrains.kotlin.commonizer.mergedtree.findClass
-import org.jetbrains.kotlin.commonizer.util.transitiveClosure
 import org.jetbrains.kotlin.descriptors.Visibilities
 
 internal interface CirSupertypesResolver {
+    /**
+     * Resolves all *declared* supertypes (not their transitive closure)
+     */
     fun supertypes(type: CirClassType): Set<CirClassType>
 }
 
-internal fun CirSupertypesResolver.allSupertypes(type: CirClassType): Set<CirClassType> {
-    return transitiveClosure(type, this::supertypes)
-}
-
+/**
+ * Very simple and pragmatic implementation of [CirSupertypesResolver]
+ * Limitations:
+ * - Will not resolve parameterized types
+ * - Supertypes from dependencies are resolved in a "best effort" manner.
+ */
 internal class SimpleCirSupertypesResolver(
     private val classifiers: CirClassifierIndex,
     private val dependencies: CirProvidedClassifiers,
@@ -27,33 +31,33 @@ internal class SimpleCirSupertypesResolver(
 
     override fun supertypes(type: CirClassType): Set<CirClassType> {
         classifiers.findClass(type.classifierId)?.let { classifier ->
-            return supertypes(type, classifier)
+            return supertypesFromCirClass(type, classifier)
         }
 
         dependencies.classifier(type.classifierId)?.let { classifier ->
             if (classifier is CirProvided.Class) {
-                return supertypes(type, classifier)
+                return supertypesFromProvidedClass(type, classifier)
             }
         }
         return emptySet()
     }
 
-    private fun supertypes(type: CirClassType, classifier: CirClass): Set<CirClassType> {
+    private fun supertypesFromCirClass(type: CirClassType, classifier: CirClass): Set<CirClassType> {
         return classifier.supertypes.filterIsInstance<CirClassType>()
-            .mapNotNull { superType -> createSupertype(type, superType) }
+            .mapNotNull { superType -> buildSupertypeFromClassifierSupertype(type, superType) }
             .toSet()
     }
 
-    private fun supertypes(type: CirClassType, classifier: CirProvided.Class): Set<CirClassType> {
+    private fun supertypesFromProvidedClass(type: CirClassType, classifier: CirProvided.Class): Set<CirClassType> {
         return classifier.supertypes.filterIsInstance<CirProvided.ClassType>()
             .mapNotNull { superType -> superType.toCirClassTypeOrNull() }
-            .mapNotNull { superType -> createSupertype(type, superType) }
+            .mapNotNull { superType -> buildSupertypeFromClassifierSupertype(type, superType) }
             .toSet()
     }
 
-    private fun createSupertype(type: CirClassType, supertype: CirClassType): CirClassType? {
+    private fun buildSupertypeFromClassifierSupertype(type: CirClassType, supertype: CirClassType): CirClassType? {
         if (type.arguments.isEmpty() && supertype.arguments.isEmpty()) {
-            return supertype
+            return supertype.makeNullableIfNecessary(type.isMarkedNullable)
         }
 
         return null