K2 kapt: generate full error type FQ name in annotation arguments

 #KT-79136 Fixed

Author: udalov

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirCallResolver.kt

@@ -827,7 +827,7 @@ class FirCallResolver(
                             explicitReceiver.resolvedType,
                         )
                     reference is FirSuperReference && (reference.superTypeRef.firClassLike(session) as? FirClass)?.isInterface == true -> ConeNoConstructorError
-                    else -> ConeUnresolvedNameError(name, operatorToken)
+                    else -> ConeUnresolvedNameError(name, operatorToken, explicitReceiver?.resolvedType)
                 }
             }
 

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/diagnostics/ConeDiagnostics.kt

@@ -73,6 +73,7 @@ class ConeUnresolvedTypeQualifierError(val qualifiers: List<FirQualifierPart>) :
 class ConeUnresolvedNameError(
     val name: Name,
     val operatorToken: String? = null,
+    val receiverType: ConeKotlinType? = null,
 ) : ConeUnresolvedError {
     override val qualifier: String get() = name.asString()
     override val reason: String get() = "Unresolved name: $prettyReference"

plugins/kapt/kapt-compiler/src/org/jetbrains/kotlin/kapt/stubs/KaptStubConverter.kt

@@ -49,6 +49,7 @@ import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterResolved
 import org.jetbrains.kotlin.fir.references.resolved
 import org.jetbrains.kotlin.fir.references.toResolvedEnumEntrySymbol
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
@@ -1570,26 +1571,32 @@ class KaptStubConverter(val kaptContext: KaptContextForStubGeneration, val gener
 
     private fun convertFirType(originalType: ConeKotlinType): JCExpression? {
         val type = originalType.fullyExpandedType(kaptContext.firSession!!)
-        val fqName = when (type) {
-            is ConeErrorType -> (type.diagnostic as? ConeUnresolvedError)?.qualifier
-            is ConeLookupTagBasedType -> {
-                val classId = (type.lookupTag as? ConeClassLikeLookupTag)?.classId ?: return null
-                val fqName = classId.asSingleFqName()
-                if (classId.packageFqName == StandardNames.BUILT_INS_PACKAGE_FQ_NAME) {
-                    val primitiveType = PrimitiveType.getByShortName(classId.relativeClassName.asString())
-                    if (primitiveType != null) {
-                        return treeMaker.Type(Type.getType(JvmPrimitiveType.get(primitiveType).desc))
-                    }
-                    val primitiveArrayType = PrimitiveType.getByShortArrayName(classId.relativeClassName.asString())
-                    if (primitiveArrayType != null) {
-                        return treeMaker.Type(Type.getType("[" + JvmPrimitiveType.get(primitiveArrayType).desc))
-                    }
-                }
-                JavaToKotlinClassMap.mapKotlinToJava(fqName.toUnsafe())?.asSingleFqName()?.asString() ?: fqName.asString()
+        if (type is ConeErrorType) {
+            val diagnostic = type.diagnostic as? ConeUnresolvedError
+            val simpleName = diagnostic?.qualifier ?: return null
+            val outerType = (diagnostic as? ConeUnresolvedNameError)?.receiverType
+            return if (outerType == null) {
+                treeMaker.SimpleName(simpleName)
+            } else {
+                treeMaker.Select(convertFirType(outerType), treeMaker.name(simpleName))
             }
-            else -> null
-        } ?: return null
-        return treeMaker.FqName(fqName)
+        }
+        if (type !is ConeLookupTagBasedType) return null
+        val classId = (type.lookupTag as? ConeClassLikeLookupTag)?.classId ?: return null
+        val fqName = classId.asSingleFqName()
+        if (classId.packageFqName == StandardNames.BUILT_INS_PACKAGE_FQ_NAME) {
+            val primitiveType = PrimitiveType.getByShortName(classId.relativeClassName.asString())
+            if (primitiveType != null) {
+                return treeMaker.Type(Type.getType(JvmPrimitiveType.get(primitiveType).desc))
+            }
+            val primitiveArrayType = PrimitiveType.getByShortArrayName(classId.relativeClassName.asString())
+            if (primitiveArrayType != null) {
+                return treeMaker.Type(Type.getType("[" + JvmPrimitiveType.get(primitiveArrayType).desc))
+            }
+        }
+        return treeMaker.FqName(
+            JavaToKotlinClassMap.mapKotlinToJava(fqName.toUnsafe())?.asSingleFqName()?.asString() ?: fqName.asString()
+        )
     }
 
     private fun convertAnnotationArgumentWithName(

plugins/kapt/kapt-compiler/testData/converter/nestedClassInAnnotation.kt

@@ -0,0 +1,15 @@
+@file:Suppress("UNRESOLVED_REFERENCE", "ANNOTATION_ARGUMENT_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION")
+package test
+
+import kotlin.reflect.KClass
+
+annotation class Anno(val value: Array<KClass<*>>)
+
+@Anno(value = [
+    A::class,
+    A.B::class,
+    A.B.C::class,
+])
+class Klass {
+    private lateinit var x: A.B
+}

plugins/kapt/kapt-compiler/testData/converter/nestedClassInAnnotation.txt

@@ -0,0 +1,49 @@
+package test;
+
+@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+/**
+ * public final annotation class test/Anno : kotlin/Annotation {
+ *
+ *   // signature: <init>(Lkotlin/Array;)V
+ *   public constructor(value: kotlin/Array<kotlin/reflect/KClass<*>>)
+ *
+ *   // getter: value()[Ljava/lang/Class;
+ *   public final val value: kotlin/Array<kotlin/reflect/KClass<*>>
+ *     public final get
+ *
+ *   // module name: main
+ * }
+ */
+@kotlin.Metadata()
+public abstract @interface Anno {
+
+    public abstract java.lang.Class<?>[] value();
+}
+
+////////////////////
+
+package test;
+
+@Anno(value = {A.class, A.B.class, A.B.C.class})
+/**
+ * public final class test/Klass : kotlin/Any {
+ *
+ *   // signature: <init>()V
+ *   public constructor()
+ *
+ *   // field: x:Lerror/NonExistentClass;
+ *   private final lateinit var x: error/NonExistentClass
+ *     private final get
+ *     private final set
+ *
+ *   // module name: main
+ * }
+ */
+@kotlin.Metadata()
+public final class Klass {
+    private error.NonExistentClass x;
+
+    public Klass() {
+        super();
+    }
+}