&& Objects.equals(a.getGroupId(), b.getGroupId()) //
                && Objects.equals(a.getVersion(), b.getVersion()) //
                && a.isExtensions() == b.isExtensions() //
                && dependenciesEquals(a.getDependencies(), b.getDependencies());
    }

    private static boolean dependenciesEquals(List<Dependency> a, List<Dependency> b) {

                }
                extensionPlugins.add(plugin);
            }

            for (Plugin plugin : build.getPlugins()) {
                if (plugin.isExtensions()) {
                    extensionPlugins.add(plugin);
                }
            }
        }

        if (extensionPlugins.isEmpty()) {
            if (logger.isDebugEnabled()) {

            // MNG-1911 / MNG-5572: Building plugins with extensions cannot be part of reactor
            for (Plugin plugin : project.getBuildPlugins()) {
                if (plugin.isExtensions()) {
                    String pluginKey =
                            ArtifactUtils.key(plugin.getGroupId(), plugin.getArtifactId(), plugin.getVersion());

                    if (projectsMap.containsKey(pluginKey)) {

            throws PluginResolutionException, PluginContainerException {
        Plugin plugin = pluginDescriptor.getPlugin();
        MavenProject project = session.getCurrentProject();

        if (plugin.isExtensions()) {
            ExtensionRealmCache.CacheRecord extensionRecord;
            try {
                RepositorySystemSession repositorySession = session.getRepositorySession();

          </association>
        </field>
      </fields>
      <codeSegments>
        <codeSegment>
          <version>4.0.0+</version>
          <code>
            <![CDATA[
    public boolean isExtensions() {
        return (getExtensions() != null) ? Boolean.parseBoolean(getExtensions()) : false;
    }
            ]]>
          </code>
        </codeSegment>
        <codeSegment>

        }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion {
            firSymbol.fir.hasStableParameterNames
        }

    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }

    override val receiverParameter: KaReceiverParameterSymbol? get() = withValidityAssertion { firSymbol.receiver(builder) }

var intOrStringFormat = intstr.IntOrString{}.OpenAPISchemaFormat()

func isExtension(schema *spec.Schema, key string) bool {
	v, ok := schema.Extensions.GetBool(key)
	return v && ok
}

func isXIntOrString(schema *spec.Schema) bool {
	// built-in types have the Format while CRDs use extension
	// both are valid, checking both
	return schema.Format == intOrStringFormat || isExtension(schema, extIntOrString)
}

import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension

internal class KaFe10DescAnonymousFunctionSymbol(
    override val descriptor: FunctionDescriptor,
    override val analysisContext: Fe10AnalysisContext
) : KaAnonymousFunctionSymbol(), KaFe10DescMemberSymbol<FunctionDescriptor> {
    override val isExtension: Boolean
        get() = withValidityAssertion { descriptor.isExtension }

        get() = withValidityAssertion { descriptor.isConst }

    override val isVal: Boolean
        get() = withValidityAssertion { !descriptor.isVar }

    override val isExtension: Boolean
        get() = withValidityAssertion { descriptor.isExtension }

    override val isFromPrimaryConstructor: Boolean
        get() = withValidityAssertion { psi is KtParameter }

    override val isStatic: Boolean

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion {
            firSymbol.fir.hasStableParameterNames
        }
    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }


    override fun createPointer(): KaSymbolPointer<KaAnonymousFunctionSymbol> = withValidityAssertion {