Imports from companion objects should have owningClass information (#5862)

Author: jevanlingen

rewrite-kotlin/src/main/kotlin/org/openrewrite/kotlin/KotlinTypeMapping.kt

@@ -224,9 +224,15 @@ class KotlinTypeMapping(
             return null
         }
 
-        // If the symbol is not resolvable we return a NEW ShallowClass to prevent caching on a potentially resolvable class type.
-        val sym = type.importedFqName!!.topLevelClassAsmType().classId.toSymbol(firSession) ?: return ShallowClass.build(signature)
-        return type(sym.fir, signature)
+        // If the symbol is not resolvable, we return a NEW ShallowClass to prevent caching on a potentially resolvable class type.
+        return type.importedFqName!!.topLevelClassAsmType().classId.toSymbol(firSession)
+            ?.let { type(it.fir, signature) }
+            ?: ShallowClass.build(signature)
+                .withOwningClass(
+                    (type as? FirResolvedImport)?.resolvedParentClassId?.toSymbol(firSession)
+                        ?.let { it as? FirRegularClassSymbol }
+                        ?.let { TypeUtils.asFullyQualified(type(it.fir, signature)) }
+                )
     }
 
     private fun packageDirective(signature: String): JavaType? {

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/tree/ImportTest.java

@@ -20,6 +20,8 @@
 import org.junit.jupiter.params.provider.CsvSource;
 import org.openrewrite.Issue;
 import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+import org.openrewrite.java.tree.TypeUtils;
 import org.openrewrite.kotlin.KotlinIsoVisitor;
 import org.openrewrite.test.RewriteTest;
 
@@ -182,4 +184,45 @@ void quotedImportWithDollar() {
           )
         );
     }
+
+    @Test
+    void interfaceInformation() {
+        rewriteRun(
+          kotlin(
+            """
+              package org.example
+              interface SuperShared {
+                  fun one() = "one"
+              }
+              interface Shared : SuperShared
+              class A {
+                  companion object : Shared
+              }
+              """
+          ),
+          kotlin(
+            """
+              import org.example.A.Companion.one
+              """,
+            spec -> spec.afterRecipe(cu -> {
+                JavaType firstImportType = cu.getImports().getFirst().getQualid().getType();
+                JavaType.FullyQualified fullyQualified = TypeUtils.asFullyQualified(firstImportType);
+
+                //noinspection DataFlowIssue
+                assertThat(fullyQualified.getOwningClass().getInterfaces())
+                  .singleElement()
+                  .satisfies(sharedInterface -> {
+                      assertThat(sharedInterface.getFullyQualifiedName()).isEqualTo("org.example.Shared");
+                      assertThat(sharedInterface.getInterfaces())
+                        .singleElement()
+                        .satisfies(it -> {
+                            assertThat(it.getFullyQualifiedName()).isEqualTo("org.example.SuperShared");
+                            assertThat(it.getMethods()).singleElement().extracting(JavaType.Method::getName).isEqualTo("one");
+                        });
+                  });
+              }
+            )
+          )
+        );
+    }
 }