- transitive dependencies are dependencies that your component needs, but only because another dependency needs them.

It's quite common that issues with dependency management are about _transitive dependencies_.
Often developers incorrectly fix transitive dependency issues by adding _direct dependencies_.
To avoid this, Gradle provides the concept of _dependency constraints_.

[[sec:adding-constraints-transitive-deps]]

	if err != nil {
		return cfg, err
	}

	cfg.Enabled = true
	cfg.DialTimeout = defaultDialTimeout
	cfg.DialKeepAliveTime = defaultDialKeepAlive
	// Disable etcd client SDK logging, etcd client
	// incorrectly starts logging in unexpected data
	// format.
	cfg.LogConfig = &zap.Config{
		Level:    zap.NewAtomicLevelAt(zap.FatalLevel),
		Encoding: "console",
	}
	cfg.Endpoints = etcdEndpoints

     */
    boolean isToolingApiStdinInEmbeddedModeSupported();

    /**
     * Returns true if the tooling API of this distribution incorrectly locks build action implementation classes.
     */
    boolean isToolingApiLocksBuildActionClasses();

    /**
     * Returns the version of the artifact cache layout
     */
    CacheVersion getArtifactCacheLayoutVersion();

    /**

        expect:
        compare(larger, smaller) > 0
        compare(smaller, larger) < 0

        where:
        larger  | smaller
        "1.0.0" | "1.0"
        "1.0.0" | "1"
    }

    def "incorrectly compares Maven snapshot-like versions (current behaviour not necessarily desired behaviour"() {
        expect:
        compare(smaller, larger) < 0
        compare(larger, smaller) > 0

		if importErrors {
			// don't use the universe scope without correct imports
			// (objects in the universe may be shadowed by imports;
			// with missing imports, identifiers might get resolved
			// incorrectly to universe objects)
			pkgScope.Outer = nil
		}
		i := 0
		for _, ident := range file.Unresolved {
			if !resolve(fileScope, ident) {
				p.errorf(ident.Pos(), "undeclared name: %s", ident.Name)

    on his policy is granted more privileges than restricted
    by the users IAM policy.

    This is due to an issue of prefix based Matcher() function
    which was incorrectly matching prefix based on resource
    prefixes instead of exact match.
```

	doDiff    = flag.Bool("diff", false, "display diffs instead of rewriting files")
	goVersion = flag.String("go", "", "go language version for files")
)

// enable for debugging fix failures
const debug = false // display incorrectly reformatted source and exit

func usage() {
	fmt.Fprintf(os.Stderr, "usage: go tool fix [-diff] [-r fixname,...] [-force fixname,...] [path ...]\n")
	flag.PrintDefaults()

	s.c = 0
	s.i = 0
	s.n = chunk
}

// Refill refills the state with more random values.
// After a call to Refill, an immediate call to Next will succeed
// (unless multiple goroutines are incorrectly sharing a state).
func (s *State) Refill() {
	s.c += ctrInc
	if s.c == ctrMax {
		// Reseed with generated uint64s for forward secrecy.
		// Normally this is done immediately after computing a block,

		if line != "" {
			// Found non-comment non-blank line.
			// Ends space for valid //go:build comments,
			// but also ends the fraction of the file we can
			// reliably parse. From this point on we might
			// incorrectly flag "comments" inside multiline
			// string constants or anything else (this might
			// not even be a Go program). So stop.
			break
		}
	}
}

		{func(x *int) any { return (*Tint)(x) }, func(v Tinter) { finalize((*int)(v.(*Tint))) }},
		// Test case for argument spill slot.
		// If the spill slot was not counted for the frame size, it will (incorrectly) choose
		// call32 as the result has (exactly) 32 bytes. When the argument actually spills,
		// it clobbers the caller's frame (likely the return PC).
		{func(x *int) any { return x }, func(v any) [4]int64 {