*     <li>Changes for the property can be queried via {@link org.gradle.work.InputChanges}</li>
     * </ul>
     */
    INCREMENTAL(true, false),

    /**
     * Primary (incremental) inputs.
     *
     * <ul>
     *     <li>Changes to the property value can cause an incremental execution</li>
     *     <li>Changes for the property can be queried via {@link org.gradle.work.InputChanges}</li>

     * Implementations may then fail on subsequent changes, or generate a deprecation warning and ignore changes.
     */
    void implicitFinalizeValue();

     * - A new getter `getX` is added, where the old getter is a boolean getter `isX` of an upgraded property
     * - A return type is changed for a getter `getX` of an upgraded property
     *
     * We don't automatically accept changes when the @since annotation is missing, because we want to keep this information on the API.
     */

 * For example, build logic may read files or access environment variables.
 * Knowing these inputs is important for configuration caching to understand if the cache has to be invalidated when the value of the system property changes.
 * It can also be used to determine undeclared task inputs, and the likes.
 */
@NonNullApi
package org.gradle.internal.configuration.inputs;

            }
            for (JApiCompatibilityChange change : member.getCompatibilityChanges()) {
                if (IGNORED_CHANGE_TYPES.contains(change)) {
                    return null;
                }
            }
            if (member instanceof JApiHasAnnotations) {
                if (isIncubating((JApiHasAnnotations) member)) {
                    return Violation.warning(member, "Changed public API (@Incubating)");
                }

     */
    TaskDependencyContainer getTaskDependencies();

    /**
     * Finalizes the property value, if possible. This makes the value final, so that it no longer changes, but not necessarily immutable.
     */
    void maybeFinalizeValue();

    PropertyValue ABSENT = new PropertyValue() {
        @Nullable
        @Override
        public Object call() {
            return null;

import javax.inject.Inject;
import java.io.File;

/**
 * Generates Javadocs in a particular way.
 *
 * TODO: We should remove the workarounds here and migrate some of the changes here into the Javadoc task proper.
 */
public abstract class GradleJavadocsPlugin implements Plugin<Project> {

    @Inject
    protected abstract FileSystemOperations getFs();

    @Override

        this.parent = parent;
    }

    @Override
    public void setTarget(ModelNode target) {
        // Once the node has been discovered, changing the target is not allowed, as it changes the promise of the node as well
        if (getState() != State.Registered) {
            throw new IllegalStateException(String.format("Cannot set target for model element '%s' as this element is not mutable.", getPath()));

     */
    FileCollectionInternal fixed(Collection<File> files);

    /**
     * Creates a {@link FileCollection} with the given files as content. The result is not live and does not reflect changes to the array.
     *
     * <p>The collection is not live. The provided array is queried on construction and discarded.
     */
    FileCollectionInternal fixed(String displayName, File... files);

    /**

     * case makes tracking of non-entries and entries with anything but strings redundant because only
     * the build script can sneak in such {@code Entry} and change the result of e.g. {@code contains}
     * call. The external world cannot influence the result, so it makes no sense to record such access
     * as an input to the configuration cache.
     * <p>