// The package e is a go/doc test for embedded methods. 
PACKAGE e

IMPORTPATH
	testdata/e

FILENAMES
	testdata/e.go

TYPES
	// T1 has no embedded (level 1) M method due to conflict. 
	type T1 struct {
		t1
		t2
	}

	// T2 has only M as top-level method. 
	type T2 struct {
		t1
	}

	// T2.M should appear as method of T2. 
	func (T2) M()

	// T3 has only M as top-level method. 
	type T3 struct {

        return new UriGradleProvider(location);
    }

    public static GradleProvider version(String version) {
        return new VersionGradleProvider(version);
    }

    public static GradleProvider embedded() {
        return new EmbeddedGradleProvider();
    }

    private static final class InstallationGradleProvider extends GradleProvider {
        private final File gradleHome;

The Kotlin DSL is embedded into the Gradle Build Tool and, just like the IDE, makes use of the Kotlin toolchain.
Both the Kotlin DSL and the Kotlin toolchain leverage the Gradle Build Cache.

image::images/C4_1_Context.svg[]

## Level 2: Container diagram

When used for the compilation of scripts of a Gradle build, the Kotlin DSL Provider compiles scripts using an embedded Kotlin compiler.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Using the same unexported name for a method as a method on an
// imported embedded type caused a gccgo compilation failure.

func addTemplates(templates *template.Template) {
	// Load specified file.
	loadFile := func(fname string) string {
		data, err := embeddedFiles.ReadFile(fname)
		if err != nil {
			fmt.Fprintf(os.Stderr, "internal/driver: embedded file %q not found\n",
				fname)
			os.Exit(1)
		}
		return string(data)
	}
	loadCSS := func(fname string) string {
		return `<style type="text/css">` + "\n" + loadFile(fname) + `</style>` + "\n"
	}

    @TargetGradleVersion(">=3.5")
    @Requires(UnitTestPreconditions.Jdk8OrEarlier)
    def "old versions can mutate environment on JDK < 9"() {
        given:
        toolingApi.requireDaemons() //cannot be run in embedded mode

        buildFile << """
            task printEnv() {
                doLast {
                    println "<" + System.getenv() + ">"
                }
            }"""

        when:

// errorcheck

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check for cycles in an embedded struct literal's method value.

package embedlitmethvalue

type T int

func (T) m() int {
	_ = x
	return 0
}

type E struct{ T }

// errorcheck

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check for cycles in an embedded struct's method call.

package embedmethcall

type T int

func (T) m() int {
	_ = x
	return 0
}

type E struct{ T }

var (
	e E
	x = e.m() // ERROR "initialization cycle|depends upon itself" 

// run

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test embedded fields of structs, including methods.

package main


type I interface {
	test1() int
	test2() int
	test3() int
	test4() int
	test5() int
	test6() int
	test7() int
}

/******
 ******
 ******/

type SubpSubp struct {

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 10219: failure of inlinable function that uses embedded types
// in an anonymous struct via :=.