* class to begin with but rather something returned from a static factory method whose declared
   * return type is plain FilenameFilter. If we made such a change, then the annotation we choose
   * here would have no significance to end users, who would be forced to conform to the signature
   * used in FilenameFilter.)
   */
  @Override
  public boolean accept(File dir, String fileName) {

// 	var y A
// 	y.m()
// 	_ = y < 0
// }

// For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639).
// // It is not permitted to declare a local type whose underlying
// // type is a type parameter not declared by that type declaration.
// func _[T any]() {
// 	type _ T         // ERROR "cannot use function type parameter T as RHS in type declaration"

                // Some tasks cannot declare the dependencies on other projects, yet, for example the dependencies task.
                // When configure on demand is enabled, those other projects are realized at execution time, long after the BuildOutputRegistry
                // has been finalized. We ignore those problems for now, until the dependencies can be declared properly.

We can do better...

## What makes a dependency

Up to now you have seen dependencies declared as functions.

But that's not the only way to declare dependencies (although it would probably be the more common).

The key factor is that a dependency should be a "callable".

            def declared = $declaredDependencyId
            def expected = $winner
            doLast {
                def deps = result.get().dependencies as List
                def projectDependency = deps.find {
                    it instanceof org.gradle.api.artifacts.result.ResolvedDependencyResult &&
                        it.requested.matchesStrictly(declared)
                }

Dependencies declared here are thus visible to the `main` and `test` compilation classpaths.

`providedRuntime`::
This configuration should be used for dependencies required at runtime but which are provided by the environment in which the WAR is deployed.
Dependencies declared here are only visible to the `main` and `test` runtime classpaths.


[NOTE]
====

		RunDespiteErrors bool
		ResultType       reflect.Type
		Requires         []*Analyzer
		FactTypes        []Fact
	}

The Flags field declares a set of named (global) flag variables that
control analysis behavior. Unlike vet, analysis flags are not declared
directly in the command line FlagSet; it is up to the driver to set the
flag variables. A driver for a single analysis, a, might expose its flag

    def "setup"() {
        buildFile << """
@Managed
interface SampleComponent extends ComponentSpec {
    String getVersion()
    void setVersion(String version)
}
"""
    }

    def "plugin declares custom component"() {
        when:
        buildWithCustomComponentPlugin()

        and:
        buildFile << '''
model {
    tasks {
        create("checkModel") {
            def components = $.components

----

=== Limitations

Support for declaring command line options currently comes with a few limitations.

- Command line options can only be declared for custom tasks via annotation.
There's no programmatic equivalent for defining options.
- Options cannot be declared globally, e.g., on a project level or as part of a plugin.

====

By default, rules declared in a project will *override* whatever is declared in settings.
It is possible to change this default, for example to always prefer the settings rules:

.Preferring rules declared in settings
====