task merge(type: FileOutputTask) {
                outputFile = layout.buildDirectory.file("merged.txt")
                inputFile = createFile.outputFile
            }

            // Set values lazily
            createFile.inputFile = layout.projectDirectory.file("file-source.txt")
            createFile.outputFile = layout.buildDirectory.file("intermediate.txt")

            buildDir = "output"
"""

//  - When loading from export data, we may load its methods and underlying
//    type lazily using a provided load function.
//  - After instantiating, we lazily expand the underlying type and methods
//    (note that instances may be created while still in the process of
//    type-checking the original type declaration).
//
// In cases 3 and 4 this lazy construction may also occur concurrently, due to

    override val evaluationSchemaForStep: EvaluationSchema by lazy(buildEvaluationAndConversionSchema)
}


/**
 * Implements a straightforward interpretation sequence step that uses the target as the top-level receiver
 * and produces an evaluation schema with [buildEvaluationAndConversionSchema] lazily before the step runs.
 */
internal

        unhandledCount++;
        return EXCEPTION_CONTINUE_EXECUTION;
    }
    return EXCEPTION_CONTINUE_SEARCH;
}

void throwFromC()
{
    DebugBreak();
}
int main()
{
    // simulate a "lazily" attached debugger, by calling some go code before attaching the exception/continue handler
    Dummy();
    exceptionCount = 0;
    continueCount = 0;

    private final ServiceRegistry serviceRegistry;

    public DependencyInjectingServiceLoader(ServiceRegistry serviceRegistry) {
        this.serviceRegistry = serviceRegistry;
    }

    /**
     * Lazily instantiates the available service type providers.
     */
    public <T> Iterable<T> load(Class<T> serviceType, ClassLoader classLoader) {
        final Instantiator instantiator = dependencyInjectingInstantiator();

        when:
        def matches = asTasks(results)

        then:
        matches == [task1]

        and:
        0 * tasks._
        0 * childTasks._
    }

    def "lazily locates all tasks for a single project"() {
        given:
        def task1 = task('task1')

        when:
        def result = resolver.selectAll(project, false)

        then:

import org.gradle.internal.component.model.VariantResolveMetadata;
import org.gradle.internal.model.CalculatedValue;

/**
 * Implementation of {@link VariantResolveMetadata} which allows variant artifacts to be calculated lazily
 * while holding a project lock.
 */
public final class LocalVariantMetadata extends DefaultVariantMetadata {
    private final CalculatedValue<ImmutableList<LocalComponentArtifactMetadata>> artifacts;

//  - When loading from export data, we may load its methods and underlying
//    type lazily using a provided load function.
//  - After instantiating, we lazily expand the underlying type and methods
//    (note that instances may be created while still in the process of
//    type-checking the original type declaration).
//
// In cases 3 and 4 this lazy construction may also occur concurrently, due to

// initialization and any server calls until a client actually needs to perform the action.
func NewLazyRESTMapperLoader(fn func() (RESTMapper, error)) RESTMapper {
	obj := &lazyObject{loader: fn}
	return obj
}

// init lazily loads the mapper and typer, returning an error if initialization has failed.
func (o *lazyObject) init() error {
	o.lock.Lock()
	defer o.lock.Unlock()
	if o.loaded {
		return o.err
	}
	o.mapper, o.err = o.loader()

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class LazyAttributesIntegrationTest extends AbstractIntegrationSpec {
    def "properties used as attribute values are read lazily"() {
        settingsFile << "rootProject.name = 'TestProject'"

        buildFile << """
            plugins {
                id 'java'
            }