* One notable exception is the computation of the early {@code session.rootDirectory}
 * property which happens very early.  The implementation used in this case
 * will be discovered using the JDK service mechanism.
 *
 * The default implementation will look for a {@code .mvn} child directory
 * or a {@code pom.xml} containing the {@code root="true"} attribute.
 *
 * @see DefaultRootLocator
 */

        then:
        NoSuchMethodException e = thrown()
        e.message == /Could not find method unknown() on JavaMethodTestSubjectSubclass./
    }

    def "default methods are discovered"() {
        expect:
        JavaMethod.of(JavaMethodTestSubjectSubclass, String, "defaultMethod").invoke(new JavaMethodTestSubjectSubclass()) == "parent-interface"
    }

        output.contains 'Output: outputFiles$2 [output2.txt]'
    }

    @ToBeFixedForConfigurationCache(because = "task references another task")
    def "nested properties are discovered"() {
        buildFile << classesForNestedProperties()
        buildFile << """
            task test(type: TaskWithNestedObjectProperty) {
                input = "someString"

 * One notable exception is the computation of the early {@code session.rootDirectory}
 * property which happens very early.  The implementation used in this case
 * will be discovered using the JDK service mechanism.
 *
 * The default implementation will look for a {@code .mvn} child directory
 * or a {@code pom.xml} containing the {@code root="true"} attribute.
 */
public interface RootLocator {

import org.gradle.nativeplatform.fixtures.AbstractInstalledToolChainIntegrationSpec
import org.gradle.nativeplatform.fixtures.app.CppCompilerDetectingTestApp

/**
 * Test that each available tool chain can be discovered and used without configuration, assuming it is in the path.
 */
class NativeToolChainDiscoveryIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {

    def helloWorldApp = new CppCompilerDetectingTestApp()

 * (via [org.gradle.api.Action] or a Kotlin function type, see [gradleConfigureLambdas]).
 *
 * All configured or returned types that appear in [isPublicAndRestricted]-matching will be discovered (for now, regardless of actual function semantics).
 */
internal
class TypeDiscoveryFromRestrictedFunctions : AnalysisSchemaComponent {
    override fun typeDiscovery(): List<TypeDiscovery> = listOf(

    @Nullable
    String findCallerForCurrentCallIfNotIntercepted(String callableName, CallKind kind);

    /**
     * Matches the current thread's innermost instrumented call as intercepted, after which it cannot be discovered with
     * {@link InstrumentedGroovyCallsTracker#findCallerForCurrentCallIfNotIntercepted}.
     *

    }

    /**
     * Returns the header directories to be used for compilation.
     */
    @Internal("The paths for include directories are tracked via the includePaths property, the contents are tracked via discovered inputs")
    public ConfigurableFileCollection getIncludes() {
        return includes;
    }

    /**
     * Add directories where the compiler should search for header files.
     */

	"Istio will try to discover the platform. Valid platform values are aws, azure, gcp, none").Get()

// Discover attempts to discover the host platform, defaulting to
// `Unknown` if a platform cannot be discovered.
func Discover(ipv6 bool) Environment {
	// First check if user has specified platform - use it if provided.
	if len(CloudPlatform) > 0 {
		switch strings.ToLower(CloudPlatform) {
		case "aws":
			return NewAWS(ipv6)

a regular build script.

[.multi-language-text.lang-kotlin]
In order for precompiled script plugins to be discovered, the `buildSrc` project needs to apply the `kotlin-dsl` plugin
in its `build.gradle.kts` file:


[.multi-language-text.lang-groovy]
In order for precompiled script plugins to be discovered, the `buildSrc` project needs to apply the `groovy-gradle-plugin` plugin
in its `build.gradle` file: