* @return `WorkResult` that can be used to check if the copy did any work.
     */
    fun copy(configuration: Action<CopySpec>): WorkResult

    /**
     * Creates a {@link CopySpec} which can later be used to copy files or create an archive.
     *
     * @return The created [CopySpec]
     */
    fun copySpec(): CopySpec

    /**

        getMainSpec().into(destPath, configureClosure);
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public CopySpec into(Object destPath, Action<? super CopySpec> copySpec) {
        getMainSpec().into(destPath, copySpec);
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public AbstractCopyTask include(String... includes) {

            FirstPassPrecompiledScript.class, Actions.doNothing());

        getFileSystemOperations().sync(copySpec -> {
            copySpec.from(getExtractedPluginRequestsClassesDirectory().getAsFileTree().getFiles()).include("**.class");
            copySpec.into(getExtractedPluginRequestsClassesStagingDirectory());
        });
    }

    dependsOn(tasks["copyMethod"])
    dependsOn(tasks["copyMethodWithExplicitDependencies"])
}

val appClasses = layout.buildDirectory.dir("classes")

// tag::standalone-copyspec[]
val webAssetsSpec: CopySpec = copySpec {
    from("src/main/webapp")
    include("**/*.html", "**/*.png", "**/*.jpg")
    rename("(.+)-staging(.+)", "$1$2")
}

tasks.register<Copy>("copyAssets") {

     * method.
     *
     * @param closure Closure to configure the CopySpec
     * @return The CopySpec
     */
    CopySpec copySpec(Closure closure);

    /**
     * Creates a directory and returns a file pointing to it.
     *
     * @param path The path for the directory to be created. Evaluated as per {@link #file(Object)}.
     * @return the created directory

        DeprecationLogger.whileDisabled(() -> convention.setExecutableDir(executableDir));
    }

    @Override
    public CopySpec getApplicationDistribution() {
        return DeprecationLogger.whileDisabled(convention::getApplicationDistribution);
    }

    @Override
    public void setApplicationDistribution(CopySpec applicationDistribution) {

            compileBuildScript(scriptPlugin, compileClassLoader);
        }

        fileSystemOperations.sync(copySpec -> {
            copySpec.from(intermediatePluginClassesDirectory.get().getAsFileTree().getFiles());
            copySpec.into(getPrecompiledGroovyScriptsOutputDirectory());
        });
        ClassLoaderUtils.tryClose(compileClassLoader);
    }

            }
            fileTree
        }
        copySpec.walk(_) >> { Action it -> it.execute(copySpecResolver) }
    }

    void actions(Closure... actions) {
        copySpecResolver.allCopyActions >> actions.collect { new ClosureBackedAction<>(it) }
    }

    void visit() {
        executer.execute(copySpec, delegate)
    }

 * For `Action` arguments, look at the type's parameter.
+
In the example above, the method signature is `copy(Action<? super CopySpec>)` and it's the bit inside the angle brackets that tells you the delegate type — link:{javadocPath}/org/gradle/api/file/CopySpec.html[CopySpec] in this case.

        override fun copy(action: Action<in CopySpec>): WorkResult {
            onAccess("copy")
            return delegate.copy(action)
        }

        override fun copySpec(closure: Closure<*>): CopySpec {
            onAccess("copySpec")
            return delegate.copySpec(closure)
        }

        override fun copySpec(action: Action<in CopySpec>): CopySpec {
            onAccess("copySpec")