Fix K2 CodeGen annotation parameter resolution failure

When we have parameters of annotation like
```
// FILE: Anno.kt
package p3

@Target(AnnotationTarget.FUNCTION)
annotation class Anno(vararg val x: String)

// FILE: main.kt
import p3.Anno

@Anno("A", "B")
fun foo(): Int = 10
```
the K2 CodeGen causes an exception reporting the unresolved type
reference. A lazy resolution call fixes the issue.

In addition, FIR for the value parameter to IR conversion fails because
`Fir2IrLazyProperty` for the value parameter tries to resolve the
initializer before creating the `IrParameterSymbol`. When it checks the
`localStorage`, it reports an error for the missing `IrParameterSymbol`.
This commit adds `IrParameterSymbol` before resolving the initializer.

^KT-65099 Fixed

analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/compilerFacility/FirIdeNormalAnalysisLibrarySourceModuleCompilerFacilityTestGenerated.java

@@ -46,6 +46,12 @@ public class FirIdeNormalAnalysisLibrarySourceModuleCompilerFacilityTestGenerate
     KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/compilerFacility/compilation"), Pattern.compile("^(.+)\\.(kt)$"), null, true);
   }
 
+  @Test
+  @TestMetadata("annotationWithVararg.kt")
+  public void testAnnotationWithVararg() {
+    runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/annotationWithVararg.kt");
+  }
+
   @Test
   @TestMetadata("classKinds.kt")
   public void testClassKinds() {

analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/compilerFacility/FirIdeNormalAnalysisSourceModuleCompilerFacilityTestGenerated.java

@@ -46,6 +46,12 @@ public class FirIdeNormalAnalysisSourceModuleCompilerFacilityTestGenerated exten
     KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/compilerFacility/compilation"), Pattern.compile("^(.+)\\.(kt)$"), null, true);
   }
 
+  @Test
+  @TestMetadata("annotationWithVararg.kt")
+  public void testAnnotationWithVararg() {
+    runTest("analysis/analysis-api/testData/components/compilerFacility/compilation/annotationWithVararg.kt");
+  }
+
   @Test
   @TestMetadata("classKinds.kt")
   public void testClassKinds() {

analysis/analysis-api/testData/components/compilerFacility/compilation/annotationWithVararg.ir.txt

@@ -0,0 +1,12 @@
+MODULE_FRAGMENT
+  FILE fqName:<root> fileName:main.kt
+    FUN name:foo visibility:public modality:FINAL <> () returnType:kotlin.Int
+      annotations:
+        Anno(x = ["A", "B"])
+      BLOCK_BODY
+        RETURN type=kotlin.Nothing from='public final fun foo (): kotlin.Int declared in <root>'
+          CONST Int type=kotlin.Int value=10
+    FUN name:test visibility:public modality:FINAL <> () returnType:kotlin.Unit
+      BLOCK_BODY
+        VAR name:x type:kotlin.Int [val]
+          CALL 'public final fun foo (): kotlin.Int declared in <root>' type=kotlin.Int origin=null

analysis/analysis-api/testData/components/compilerFacility/compilation/annotationWithVararg.kt

@@ -0,0 +1,15 @@
+// FILE: Anno.kt
+package p3
+
+@Target(AnnotationTarget.FUNCTION)
+annotation class Anno(vararg val x: String)
+
+// FILE: main.kt
+import p3.Anno
+
+@Anno("A", "B")
+fun foo(): Int = 10
+
+fun test() {
+    val x = foo()
+}

analysis/analysis-api/testData/components/compilerFacility/compilation/annotationWithVararg.txt

@@ -0,0 +1,5 @@
+public final class MainKt {
+    // source: 'main.kt'
+    public final static method foo(): int
+    public final static method test(): void
+}

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt

@@ -12,13 +12,18 @@ import org.jetbrains.kotlin.descriptors.isAnnotationClass
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.backend.generators.FirBasedFakeOverrideGenerator
 import org.jetbrains.kotlin.fir.backend.generators.generateOverriddenPropertySymbols
+import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
+import org.jetbrains.kotlin.fir.declarations.primaryConstructorIfAny
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.resolve.toFirRegularClass
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.resolvedType
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
@@ -26,6 +31,7 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
+import org.jetbrains.kotlin.ir.symbols.UnsafeDuringIrConstructionAPI
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.NameUtils
@@ -98,9 +104,21 @@ class Fir2IrLazyProperty(
     private fun toIrInitializer(initializer: FirExpression?): IrExpressionBody? {
         // Annotations need full initializer information to instantiate them correctly
         return when {
-            containingClass?.classKind?.isAnnotationClass == true -> initializer?.asCompileTimeIrInitializer(
+            containingClass?.classKind?.isAnnotationClass == true -> {
-                components, fir.returnTypeRef.coneType
+                var irInitializer: IrExpressionBody? = null
-            )
+                declarationStorage.withScope(symbol) {
+                    with(declarationStorage) {
+                        val firPrimaryConstructor =
+                            fir.containingClassLookupTag()?.toFirRegularClass(session)?.primaryConstructorIfAny(session) ?: return@with
+
+                        @OptIn(UnsafeDuringIrConstructionAPI::class)
+                        declarationStorage.getIrConstructorSymbol(firPrimaryConstructor).owner.putParametersInScope(firPrimaryConstructor.fir)
+                    }
+                    fir.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
+                    irInitializer = initializer?.asCompileTimeIrInitializer(components, fir.returnTypeRef.coneType)
+                }
+                irInitializer
+            }
             // Setting initializers to every other class causes some cryptic errors in lowerings
             initializer is FirLiteralExpression<*> -> {
                 val constType = with(typeConverter) { initializer.resolvedType.toIrType() }