if (firConstructor.isPrimary != isPrimary) return null
        return firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(firConstructor.symbol)
    }

    override fun pointsToTheSameSymbolAs(other: KaSymbolPointer<KaSymbol>): Boolean = other === this ||
            other is KaFirConstructorSymbolPointer &&
            other.signature == signature &&
            other.isPrimary == isPrimary &&

		return c.Name()
	}
	if c.IsPrimary() {
		if c.IsConfig() {
			prefix = "primary"
		} else {
			prefix = "externalistiod"
		}
	} else if c.IsRemote() {
		if c.IsConfig() {
			prefix = "config"
		} else {
			prefix = "remote"
		}
	}

	return fmt.Sprintf("%s-%d", prefix, c.Index)
}

func (c Topology) IsPrimary() bool {
	return c.Primary().Name() == c.Name()
}

    }

    override val containingClassId: ClassId?
        get() = withValidityAssertion { firSymbol.containingClassLookupTag()?.classId?.takeUnless { it.isLocal } }

    override val isPrimary: Boolean get() = withValidityAssertion { firSymbol.isPrimary }
    override val isActual: Boolean get() = withValidityAssertion { firSymbol.isActual }
    override val isExpect: Boolean get() = withValidityAssertion { firSymbol.isExpect }

	// MaxKubeVersion returns true if the cluster is at most the version specified,
	// false otherwise
	MaxKubeVersion(minor uint) bool

	// IsPrimary returns true if this is a primary cluster, containing an instance
	// of the Istio control plane.
	IsPrimary() bool

	// IsConfig returns true if this is a config cluster, used as the source of
	// Istio config for one or more control planes.
	IsConfig() bool

    override val analysisContext: Fe10AnalysisContext
) : KaConstructorSymbol(), KaFe10DescMemberSymbol<ConstructorDescriptor> {
    override val isPrimary: Boolean
        get() = withValidityAssertion { descriptor.isPrimary }

    override val containingClassId: ClassId?
        get() = withValidityAssertion { descriptor.constructedClass.classId }

        printer: PrettyPrinter,
    ) {
        val members = declarationRenderer.bodyMemberScopeProvider.getMemberScope(analysisSession, symbol)
            .filter { it !is KaConstructorSymbol || !it.isPrimary }
            .let { declarationRenderer.bodyMemberScopeSorter.sortMembers(analysisSession, it, symbol) }

        val membersToPrint = members.mapNotNull { member ->

                            declarationRenderer.bodyMemberScopeProvider.getMemberScope(analysisSession, symbol).filterIsInstance<KaConstructorSymbol>()
                                .firstOrNull { it.isPrimary }
                        else null

                        declarationRenderer.nameRenderer.renderName(analysisSession, symbol, declarationRenderer, printer)

    override val descriptor: ConstructorDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        bindingContext[BindingContext.CONSTRUCTOR, psi]
    }

    override val isPrimary: Boolean
        get() = withValidityAssertion { psi is KtPrimaryConstructor }

    override val containingClassId: ClassId?
        get() = withValidityAssertion { psi.getContainingClassOrObject().getClassId() }

public abstract class KaConstructorSymbol : KaFunctionLikeSymbol(),
    KaPossibleMemberSymbol,
    KaPossibleMultiplatformSymbol,
    KaSymbolWithVisibility {

    public abstract val isPrimary: Boolean

    /**
     * The [ClassId] of the containing class, or `null` if the class is local.
     */
    public abstract val containingClassId: ClassId?

        if (fir is FirConstructor && psi is KtConstructor<*>) {
            if (psi is KtPrimaryConstructor && fir.isPrimary) return true // There can only be one primary constructor.
            if (psi is KtPrimaryConstructor || fir.isPrimary) return false
        }

        if (!modifiersMatch(psi, fir)) return false
        if (!receiverTypeMatches(psi, fir)) return false