constructors.forEach { yield(it.toKtConstructorSymbol(analysisContext)) }
    }
}

internal open class KtFe10ScopeNonStaticMember(
    scope: MemberScope,
    constructors: Collection<ConstructorDescriptor>,
    analysisContext: Fe10AnalysisContext
) : KtFe10ScopeMember(scope, constructors, analysisContext) {

A fix will be shipped with the next incremental (1.x.y) or bug fix release (1.x.yz).

All fixes are also applied to the master branch to be included in all upcoming releases.

## Reporting a Vulnerability

import org.jetbrains.kotlin.resolve.scopes.MemberScope

internal class KtFe10PackageScope(
    scope: MemberScope,
    private val owner: KtPackageSymbol,
    analysisContext: Fe10AnalysisContext
) : KtFe10ScopeMember(scope, constructors = emptyList(), analysisContext) {
    override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {

            // a special `TypeAliasConstructorDescriptor` for this case. For FIR there is
            // FirConstructor.originalConstructorIfTypeAlias but that doesn't seem to help here as it
            // is null for the constructors we get.
            val constructedType = fir.constructedTypeRef.coneType
            val constructorReturnType = fir.calleeReference.toResolvedConstructorSymbol()?.resolvedReturnTypeRef?.type

        )
}

private fun getAsmMethodSignatureWithCorrection(method: PsiMethod): String = buildString {
    append("(")
    if (method.containingClass?.isEnum == true && method.isConstructor) {
        // Enum constructors are represented without name/ordinal in light classes, which seems fine because they don't have name/ordinal

                false

            // no children of class and script initializers are used
            is KtAnonymousInitializer ->
                false

            // no child expressions of primary constructors.
            is KtPrimaryConstructor ->
                false // error?
            // no children of secondary constructs are used.
            is KtSecondaryConstructor ->
                false

        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
            ?: return getEmptyScope()

        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, descriptor.constructors, analysisContext)
    }

    override fun getStaticMemberScope(symbol: KtSymbolWithMembers): KtScope {
        val descriptor = getDescriptor<ClassDescriptor>(symbol) ?: return getEmptyScope()

    }

    /**
     * Finds constructors with a given [targetClassName] available within the [scope], including SAM constructors
     * (which are not explicitly declared in the class).
     *
     * Includes type-aliased constructors too if typealias confirms to the [targetClassName].
     *
     * Do not confuse with constructors **declared** in the scope (see [FirScope.processDeclaredConstructors]).

            val callExpression = (psi as? KtExpression)?.getPossiblyQualifiedCallExpression()
            if (callExpression != null) {
                val constructors = findQualifierConstructors()
                val calls = toKtCalls(constructors)
                return when (calls.size) {
                    0 -> KtErrorCallInfo(listOf(KtQualifierCall(token, callExpression)), inapplicableCandidateDiagnostic(), token)

            !is KtDeclarationSymbol -> {
                // File, package, etc.
                return false
            }

            is KtSamConstructorSymbol -> {
                // SAM constructors are always top-level
                return false
            }

            is KtScriptSymbol -> {
                // Scripts are always top-level
                return false
            }