import org.gradle.internal.declarativedsl.schemaBuilder.ConfigureLambdaHandler
import org.gradle.internal.declarativedsl.schemaBuilder.kotlinFunctionAsConfigureLambda
import org.gradle.internal.declarativedsl.schemaBuilder.plus
import org.gradle.internal.declarativedsl.schemaBuilder.treatInterfaceAsConfigureLambda


/**
 * Defines configuring lambdas for schema building purposes as one of:

            }
        });

        setFrom(Cast.castNullable(FileCollection.class, object));
    }

    @Override
    public FileCollection plus(FileCollection collection) {
        return new UnionFileCollection(taskDependencyFactory, this, (FileCollectionInternal) collection);
    }

    @Override
    public void setFrom(Iterable<?> path) {

        }
    }
}


operator fun PropertyExtractor.plus(other: PropertyExtractor): CompositePropertyExtractor = CompositePropertyExtractor(buildList {
    fun include(propertyExtractor: PropertyExtractor) = when (propertyExtractor) {
        is CompositePropertyExtractor -> addAll(propertyExtractor.extractors)
        else -> add(propertyExtractor)
    }
    include(this@plus)
    include(other)
})

// See mksyscall.pl.
var _zero uintptr

// Unix returns the time stored in ts as seconds plus nanoseconds.
func (ts *Timespec) Unix() (sec int64, nsec int64) {
	return int64(ts.Sec), int64(ts.Nsec)
}

// Unix returns the time stored in tv as seconds plus nanoseconds.
func (tv *Timeval) Unix() (sec int64, nsec int64) {
	return int64(tv.Sec), int64(tv.Usec) * 1000
}

    /**
     * Packages up the result of a {@link BuildAction}, either success plus an optional result object, or failure.
     *

    }

    @Override
    String toString() {
        return "[instant at $nanos]"
    }

    int compareTo(Instant t) {
        return nanos.compareTo(t.nanos)
    }

    Instant plus(long millis) {
        return new Instant(nanos + millis * 1000)
    }

    Duration minus(Instant t) {
        return new Duration(nanos - t.nanos)
    }

 */
interface MapSupplier<K, V> extends ValueSupplier {
    Value<? extends Map<K, V>> calculateValue(ValueConsumer consumer);

    Value<? extends Set<K>> calculateKeys(ValueConsumer consumer);

    MapSupplier<K, V> plus(MapCollector<K, V> collector);

    /**
     * Returns a view of this supplier that may calculate its value as empty if it would be missing.
     */
    MapSupplier<K, V> absentIgnoring();

	output := filepath.Join(tmpdir, "fma.exe")
	cmd := testenv.Command(t, gocmd, "build", "-o", output, source)
	// The hash-dependence on file path name is dodged by specifying "all hashes ending in 1" plus "all hashes ending in 0"
	// i.e., all hashes.  This will print all the FMAs; this test is only interested in one of them (that should appear near the end).

        return null;
    }

    @Override
    public void fetchFirst(int fetchSize) {
        _fetchScopeEffective = true;
        if (fetchSize < 0) {
            String msg = "Argument[fetchSize] should be plus: " + fetchSize;
            throw new IllegalArgumentException(msg);
        }
        _fetchStartIndex = 0;
        _fetchSize = fetchSize;
        _fetchPageNumber = 1;
        doClearFetchPageClause();

        return null;
    }

    @Override
    public void fetchFirst(int fetchSize) {
        _fetchScopeEffective = true;
        if (fetchSize < 0) {
            String msg = "Argument[fetchSize] should be plus: " + fetchSize;
            throw new IllegalArgumentException(msg);
        }
        _fetchStartIndex = 0;
        _fetchSize = fetchSize;
        _fetchPageNumber = 1;
        doClearFetchPageClause();