// 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) }

}

func bigcap() {
	g1 = make([]block, 10, big)
}

type cblock [1<<16 - 1]byte

var g4 chan cblock

func badchancap() {
	g4 = make(chan cblock, minus1)
}

func bigchancap() {
	g4 = make(chan cblock, big)
}

func overflowchan() {
	const ptrSize = unsafe.Sizeof(uintptr(0))
	g4 = make(chan cblock, 1<<(30*(ptrSize/4)))
}

func main() {
	shouldfail(badlen, "badlen")

    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]+ ;

  // dynamic_partition(data, partitions, num_partitions) = {
  //   [10, 20, 50],
  //   [30, 40]
  // }
  // grads = {
  //   [g1, g2, g3],
  //   [g4, g5]
  // }
  // The desired propagation of the gradients back to the data inputs is:
  // [g1, g2, g4, g5, g3]
  auto data = op.input(0);
  auto partitions = op.input(1);
  int32_t num_partitions;
  TF_RETURN_IF_ERROR(

	g3 := method4a.I1.Sum
	eq(g3(mt1, a, 38), 48)
	eq(g3(mt2, a, 39), 49)

	eq(method4a.I2.Sum(mt1, a, 40), 50)
	eq(method4a.I2.Sum(mt2, a, 41), 51)

	g4 := method4a.I2.Sum
	eq(g4(mt1, a, 42), 52)
	eq(g4(mt2, a, 43), 53)

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

var G1 int
var G2 int
var G3 int
var G4 int
var G5 int
var G6 int
var G7 int
var G8 int
var G9 int

        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"},