There are several options for customization, as you’ll see next.

NOTE: All link:{groovyDslPath}/org.gradle.language.swift.tasks.SwiftCompile.html[SwiftCompile] tasks are incremental and cacheable.

[[sec:swift_supported_tool_chain]]
=== Supported tool chain

Gradle support the https://swift.org/download/[official Swift tool chain for macOS and Linux].

        outputContains 'sys prop value at execution time = 37'
        configurationCache.assertStateStored()
    }

    @Issue("gradle/gradle#14465")
    def "configuration is cacheable when providers are used in settings"() {

        given:
        def configurationCache = newConfigurationCacheFixture()
        settingsFile << """

=== Example: Testing cacheable tasks

[source,groovy,indent=0]
.BuildLogicFunctionalTest.groovy
----

            includeLink()
        }

        then:
        outputEquals """
Type 'Hello' property 'world' is declared to be sensitive to absolute paths.

Reason: This is not allowed for cacheable transforms.

Possible solution: Use a different normalization strategy via @PathSensitive, @Classpath or @CompileClasspath.

${validationMessage("cacheable_transform_cant_use_absolute_sensitivity")}
"""
    }

There are several options for customization, as you’ll see next.

NOTE: All link:{groovyDslPath}/org.gradle.language.cpp.tasks.CppCompile.html[CppCompile] tasks are incremental and cacheable.

[[sec:cpp_supported_tool_chain]]
=== Supported tool chain

Gradle offers the ability to execute the same build using different tool chains.

 * {@link #setShowSinglePathToDependency(boolean)}, and {@link #getShowingAllVariants()}.
 */
@DisableCachingByDefault(because = "Produces only non-cacheable console output")
public abstract class DependencyInsightReportTask extends DefaultTask {

    private Spec<DependencyResult> dependencySpec;
    private boolean showSinglePathToDependency;

 * is still valid. Such responses increment both the network count and hit count.
 *
 * The best way to improve the cache hit rate is by configuring the web server to return cacheable
 * responses. Although this client honors all [HTTP/1.1 (RFC 7234)][rfc_7234] cache headers, it
 * doesn't cache partial responses.
 *
 * ## Force a Network Response
 *

		// (and is often associated with an error result).

	case query == module.CanonicalVersion(query):
		// This query refers to a specific version, and Go module versions
		// are supposed to be cacheable and immutable (confirmed with checksums).
		// If the version exists at all, we shouldn't need any extra information
		// to identify which commit it resolves to.
		//

		h.WriteString(b.service.Attributes.Namespace)
	}
	h.Write(Separator)

	if b.proxyView != nil {
		h.WriteString(b.proxyView.String())
	}
	h.Write(Separator)
}

func (b *EndpointBuilder) Cacheable() bool {
	// If service is not defined, we cannot do any caching as we will not have a way to
	// invalidate the results.
	// Service being nil means the EDS will be empty anyways, so not much lost here.

        def config = display(SimpleMessage, 'cacheable_transform_cant_use_absolute_sensitivity', spec)
        config.description("is declared to be sensitive to absolute paths")
            .reason("This is not allowed for cacheable transforms")
            .solution("Use a different normalization strategy via @PathSensitive, @Classpath or @CompileClasspath")
            .render()
    }