[[sec::declare_feature_variants]]
== Registering features

Features can be declared by applying the `java-library` plugin.
The following code illustrates how to declare a feature named `mongodbSupport`:

.Registering a feature
====

		check.error(ident, InvalidInitDecl, "cannot declare init - must be func")
		return
	}

	// spec: "The main package must have package name main and declare
	// a function main that takes no arguments and returns no value."
	if ident.Value == "main" && check.pkg.name == "main" {
		check.error(ident, InvalidMainDecl, "cannot declare main - must be func")
		return
	}

	check.declare(check.pkg.scope, ident, obj, nopos)

    }

    def "does not allow replacing with self"() {
        declaredReplacements 'a->a'
        expect:
        fails().assertHasCause("Cannot declare module replacement that replaces self: org:a->org:a")
    }

    def "when multiple replacement targets declared only the last one applies"() {
        publishedMavenModules 'c'
        declaredDependencies 'a', 'b', 'c'
        declaredReplacements 'a->b', 'a->c'

        true        | 'conflict fix applied'
    }

    /**
     * This test highlights the case where published module declares a relocation. This is the drop-in replacement
     * for "replacedBy" rules when a module has been relocated, and that the publisher uses Gradle. There's the
     * ability to declare, in a newer version of the module, that it actually provides the same capability as an

}

// OptionalVariableDeclarations declares which optional CEL variables
// are declared for an expression.
type OptionalVariableDeclarations struct {
	// HasParams specifies if the "params" variable is declared.
	// The "params" variable may still be bound to "null" when declared.
	HasParams bool
	// HasAuthorizer specifies if the "authorizer" and "authorizer.requestResource"
	// variables are declared. When declared, the authorizer variables are

		var x2 /* ERROR "declared and not used" */ int
		x1 = 1
		(x2) = 2

		y1 /* ERROR "declared and not used" */ := 1
		y2 /* ERROR "declared and not used" */ := 2
		y1 = 1
		(y1) = 2
	}

	if x /* ERROR "declared and not used" */ := 0; a < b {}

	switch x /* ERROR "declared and not used" */, y := 0, 1; a {
	case 0:
		_ = y
	case 1:
		x /* ERROR "declared and not used" */ := 0
	}

And if you declared a `response_model`, it will still be used to filter and convert the object you returned.

**FastAPI** will use that *temporal* response to extract the status code (also cookies and headers), and will put them in the final response that contains the value you returned, filtered by any `response_model`.

You can also declare singular values to be received as part of the body.

// license that can be found in the LICENSE file.

package P

// 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 parameters not declared by that type declaration.
// func _[T any]() {
// 	type _ T         // ERROR "cannot use function type parameter T as RHS in type declaration"

            }
        }
        run ':checkDeps'

        then:
        outputContains 'Rule from settings applied on org:module:1.0'
    }

    def "doesn't apply rules from settings if project declares rules"() {
        withLoggingRuleInSettings()
        repository {
            'org:module:1.0'()
        }
        buildFile << """
            dependencies {
                conf 'org:module:1.0'