analysisContext: Fe10AnalysisContext,
    index: Int,
): KtAnnotationApplicationWithArgumentsInfo {
    return KtAnnotationApplicationWithArgumentsInfo(
        classId = classIdForAnnotation,
        psi = psi,
        useSiteTarget = useSiteTarget,
        arguments = getKtNamedAnnotationArguments(analysisContext),
        index = index,
        constructorSymbolPointer = null,

        val type = if (typeParameters.size == builder.arguments.size) {
            val projections = builder.arguments.mapIndexed { index, arg ->
                when (arg) {
                    is KtStarTypeProjection -> StarProjectionImpl(typeParameters[index])
                    is KtTypeArgumentWithVariance -> TypeProjectionImpl(arg.variance, (arg.type as KtFe10Type).fe10Type)
                }
            }

            }
        }
    }

    private fun writeInnerParts(innerTypesAsList: List<PossiblyInnerType>, sw: JvmSignatureWriter, mode: TypeMappingMode, index: Int) {
        for (innerPart in innerTypesAsList.subList(index, innerTypesAsList.size)) {
            sw.writeInnerClass(getJvmShortName(innerPart.classDescriptor))
            writeGenericArguments(sw, innerPart, mode)
        }
    }

            }
        }
    }

    private fun collectImplicitReceivers(scope: LexicalScope): MutableList<KtImplicitReceiver> {
        val result = mutableListOf<KtImplicitReceiver>()

        for ((index, implicitReceiver) in scope.getImplicitReceiversHierarchy().withIndex()) {
            val type = implicitReceiver.type.toKtType(analysisContext)
            val ownerDescriptor = implicitReceiver.containingDeclaration

    }.orEmpty()

    return toKtAnnotationApplication(builder, index, arguments)
}

private fun FirAnnotation.asKtAnnotationApplicationForTargetAnnotation(
    builder: KtSymbolByFirBuilder,
    index: Int,
): KtAnnotationApplicationWithArgumentsInfo = asKtAnnotationApplicationForAnnotationWithEnumArgument(
    builder = builder,
    index = index,
    expectedEnumClassId = StandardClassIds.AnnotationTarget,

        val typeProjection = call.typeArguments.find { it.typeReference == ktTypeReference } ?: return null
        val index = call.typeArguments.indexOf(typeProjection)
        val paramDescriptor = resolvedCall.candidateDescriptor.typeParameters.find { it.index == index } ?: return null
        return resolvedCall.typeArguments[paramDescriptor]
    }

            mapNotIgnoredAnnotationsWithIndex { index, annotation ->
                annotation.toKtAnnotationApplication(analysisContext, index)
            }
        }

    override val annotationInfos: List<KtAnnotationApplicationInfo>
        get() = withValidityAssertion {
            mapNotIgnoredAnnotationsWithIndex { index, annotation ->
                annotation.toKtAnnotationInfo(analysisContext, index)
            }
        }

 * stub-indexing binary libraries). And in general, querying the symbol names provider might be faster since its sets are cached, which is
 * not necessarily the case for declaration providers (e.g. the IDE declaration provider hitting the index without caching).
 *
 * However, since symbol names providers may not be able to compute name sets per their contract, we may have to fall back to the

        useSiteTarget = useSiteTarget,
        arguments = arguments,
        index = index,
        constructorSymbolPointer = with(builder.analysisSession) { constructorSymbol?.createPointer() },
        token = builder.token,
    )
}

internal fun FirAnnotation.toKtAnnotationInfo(
    useSiteSession: FirSession,
    index: Int,
    token: KtLifetimeToken
): KtAnnotationApplicationInfo = KtAnnotationApplicationInfo(

        KtPsiBasedSymbolPointer.createForSymbolFromSource<KtClassInitializerSymbol>(this)?.let { return it }
        TODO("Figure out how to create such a pointer. Should we give an index to class initializers?")
    }

    override val symbolKind: KtSymbolKind get() = withValidityAssertion { KtSymbolKind.CLASS_MEMBER }