return getElements().toArray(a);
    }

    @Override
    public boolean add(T e) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean remove(Object o) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return getElements().containsAll(c);
    }

 * * the error causes, thus considering all error nodes equal to each other but not to any other node.
 */
fun DeclarativeDocument.structurallyEqualsAsData(other: DeclarativeDocument): Boolean {
    fun ValueNode.structurallyEquals(other: ValueNode): Boolean = when (this) {
        is LiteralValueNode -> other is LiteralValueNode &&
            value == other.value

        is ValueFactoryNode -> other is ValueFactoryNode &&

            // Prefer implementation methods over abstract or bridge methods
            methods.put(key, method);
        }
    }

    private boolean shouldReplace(Method current, Method method) {
        boolean currentAbstract = Modifier.isAbstract(current.getModifiers());
        boolean newAbstract = Modifier.isAbstract(method.getModifiers());
        if (currentAbstract != newAbstract) {
            // Prefer non-abstract over abstract

    }

    public String getMostSpecificSignature() {
        return mostSpecificSignature;
    }

    public boolean isDeclaredInManagedType() {
        return declaredInManagedType;
    }

    public boolean isDeclaredAsAbstract() {
        return declaredAsAbstract;
    }

    public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
        return annotations.containsKey(annotationType);
    }

            else object : IgnoredConfigurationInputs {
                override fun isFileSystemCheckIgnoredFor(file: File): Boolean = false
            }

        private
        fun hasIgnoredPaths(configurationCacheStartParameter: ConfigurationCacheStartParameter): Boolean =
            !configurationCacheStartParameter.ignoredFileSystemCheckInputs.isNullOrEmpty()
    }

        SelfClosed(false),
        GraphClosed(false);

        public final boolean mutable;

        State(boolean mutable) {
            this.mutable = mutable;
        }

        public State previous() {
            return ModelNode.State.values()[ordinal() - 1];
        }

        public boolean isAtLeast(State state) {
            return this.ordinal() >= state.ordinal();
        }
    }

    /**
     * Checks if accessing a property by the specified name would be intercepted by the instrumentation at this
     * specific moment. The implementation may return different values at different times.
     */
    boolean interceptsPropertyAccess(String propertyName);

import java.io.Serializable


data class KotlinCompilerOptions(
    val jvmTarget: JavaVersion = JavaVersion.current(),
    val allWarningsAsErrors: Boolean = false,
    val skipMetadataVersionCheck: Boolean = true,
) : Serializable


fun kotlinCompilerOptions(gradleProperties: GradlePropertiesController): KotlinCompilerOptions =
    KotlinCompilerOptions(

    default void visitInputFileProperty(String propertyName, boolean optional, InputBehavior behavior, DirectorySensitivity directorySensitivity, LineEndingSensitivity lineEndingSensitivity, @Nullable FileNormalizer fileNormalizer, PropertyValue value, InputFilePropertyType filePropertyType) {}

    default void visitInputProperty(String propertyName, PropertyValue value, boolean optional) {}

import java.util.List;

public interface DslElementDoc {
    String getId();

    Element getDescription();

    List<Element> getComment();

    boolean isDeprecated();

    boolean isIncubating();

    boolean isReplaced();

    String getReplacement();