V = aliases.Unalias(V)
	T = aliases.Unalias(T)

	// If V and T are not both named, or do not have matching non-empty type
	// parameter lists, fall back on types.AssignableTo.

	VN, Vnamed := V.(*types.Named)
	TN, Tnamed := T.(*types.Named)
	if !Vnamed || !Tnamed {
		return types.AssignableTo(V, T)
	}

	vtparams := VN.TypeParams()
	ttparams := TN.TypeParams()

// a named type remain the same as long as the same source and AddMethod calls
// are presented to the type checker in the same order (go.dev/issue/61298).
func TestMethodOrdering(t *testing.T) {
	const src = `
package p

type T struct{}

func (T) a() {}
func (T) c() {}
func (T) b() {}
`
	// should get the same method order each time
	var methods []string

query_or_cookie_extractor(["query_or_cookie_extractor"])

read_query["/items/"]

query_extractor --> query_or_cookie_extractor --> read_query
```

## Using the same dependency multiple times

If one of your dependencies is declared multiple times for the same *path operation*, for example, multiple dependencies have a common sub-dependency, **FastAPI** will know to call that sub-dependency only once per request.

        if (attributeValue == null) {
            throw new IllegalStateException("No attribute value for " + attribute);
        }

        if (attributeValue instanceof Named) {
            return ((Named) attributeValue).getName();
        } else if (attributeValue instanceof Object[]) {
            // don't bother trying to handle primitive arrays specially

//     using exactly the same version of the toolchain, the same build
//     tags, and the same values of certain flags and environment
//     variables.
//
//   - Similar crashing problems are likely to arise unless all common
//     dependencies of the application and its plugins are built from
//     exactly the same source code.
//
//   - Together, these restrictions mean that, in practice, the

package os

import "internal/testlog"

// Stat returns a [FileInfo] describing the named file.
// If there is an error, it will be of type [*PathError].
func Stat(name string) (FileInfo, error) {
	testlog.Stat(name)
	return statNolog(name)
}

// Lstat returns a [FileInfo] describing the named file.
// If the file is a symbolic link, the returned FileInfo

        task.descendant("Snapshot inputs and outputs before executing task ':custom'")
        task.descendant("Snapshot outputs after executing task ':custom'")
    }

    def "task actions implemented in annotated methods are named after the method"() {
        given:
        buildFile << """
        task custom(type: CustomTask)

        class CustomTask extends DefaultTask {
            @TaskAction void doSomethingAmazing() { }
        }

reporting {
    reports {
        testCodeCoverageReport(JacocoCoverageReport) { // <.>
            testType = TestSuiteType.UNIT_TEST
        }
    }
}
// end::create_report[]

tasks.named('check') {
    dependsOn tasks.named('testCodeCoverageReport', JacocoReport) // <.>

}

dependencies {
    implementation project(':list')
    implementation project(':utilities')
}

application {
    mainClass = 'org.gradle.sample.Main'
}

tasks.named('check') {
    dependsOn tasks.named('testCodeCoverageReport', JacocoReport) // <2>

        configurationCacheRun 'myTask'

        and: 'convention mapping is ignored just the same'
        configurationCacheRun 'myTask'
    }

    def "restores convention mapped task input property explicitly set to null"() {
        given:
        withConventionMappingForPropertyOfType String, '"42"'
        buildFile << '''
            tasks.named("ok") {
                inputProperty = null
            }
        '''