// Therefore we can infer a type argument in this case.

type S[P any] struct{}

func g4[P any](S[P]) {}

func _() {
	var x S[int]
	g4(x)      // we can infer int for P
	g4[int](x) // int is the correct type argument
	g4[string](x /* ERROR "cannot use x (variable of type S[int]) as S[string] value in argument to g4[string]" */)
}

// This is similar to the first example but here T1 is a component

	if f2(2) != "" {
		panic(2)
	}

	if g3(g1, 3) != g1(3) {
		panic(3)
	}

	if g4(g2, 4) != "" {
		panic(4)
	}
}

func g1[P any](x P) P    { return x }
func g2[P, Q any](x P) Q { var q Q; return q }

func g3(f1 func(int) int, x int) int       { return f1(x) }

    private goodGrammar() {
        file("grammar-builder/src/main/antlr/org/acme/Test.g4") << """grammar Test;
            @header {
                package org.acme;
            }
            r  : 'hello' ID ;
            ID : [a-z]+ ;
            WS : [ \\t\\r\\n]+ -> skip ;
        """

        file("grammar-builder/src/main/antlr/Another.g4") << """grammar Another;
            r  : 'hello' ID ;
            ID : [a-z]+ ;

        anyOf(moduleIdSet(["G:A"], ["G2:P"]), groupSet("G3", "G4"))                                                    | moduleIdSet(["G5", "A"], ["G6", "B"])                                                                                 | nothing()

        d3.versionConstraint >> requires("v3")
        d3.transitive >> true
        d3.excludeRules >> [new DefaultExcludeRule("g4", "m4"), new DefaultExcludeRule(null, "m5"), new DefaultExcludeRule("g5", null)]
        d3.attributes >> ImmutableAttributes.EMPTY

        def d4 = Stub(ExternalDependency)
        d4.group >> "g4"
        d4.name >> "m4"
        d4.versionConstraint >> requires('')
        d4.transitive >> true

            "dependencyConstraints": [
                { "module": "m3", "group": "g3", "version": { "prefers": "v3" }},
                { "module": "m4", "version": { "requires": "v4", "strictly": "v4a", "rejects": ["v5"] }, "group": "g4"},
                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                { "module": "m6", "version": { "rejects": ["+"] }, "group": "g6"},

func g2(func(int, int))                      {}
func g3(func(int) string)                    {}
func g4[P any](func(P) string)               {}
func g5[P, Q any](func(P) string, func(P) Q) {}
func g6(func(int), func(string))             {}

func _() {
	g1(f1)
	g1(f2 /* ERROR "cannot infer P" */)
	g2(f4)
	g4(f6)
	g5(f6, f7)
	g6(f1, f1)
}

// Argument passing of partially instantiated functions

            "dependencies": [
                { "module": "m3", "group": "g3", "version": { "prefers": "v3" }},
                { "module": "m4", "version": { "requires": "v4", "prefers": "v3", "rejects": ["v5"] }, "group": "g4"},
                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                { "module": "m6", "version": { "rejects": ["v8"] }, "group": "g6"},

        moduleIdSet(["g1", "m1"], ["g2", "m2"], ["g3", "m3"], ["g4", "m4"]) | moduleSet("m1", "m2")                       | anyOf(moduleIdSet(["g3", "m3"], ["g4", "m4"]), moduleSet("m1", "m2"))

        moduleId("g1", "m1")                                                | groupSet("g1", "g2")                        | groupSet("g1", "g2")

[[sec:antlr_extensions]]
== Contributed extension

`antlr` — link:{groovyDslPath}/org.gradle.api.plugins.antlr.AntlrSourceDirectorySet.html[AntlrSourceDirectorySet]::
The ANTLR grammar files of this source set. Contains all `.g` or `.g4` files found in the ANTLR source directories, and excludes all other types of files. _Default value is non-null._

[[sec:antlr_convention_properties]]
== Convention properties (deprecated)