* supersource for this class contains a field of type {@code C}.
 *
 * <p>For details about this hack, see {@code GwtSerializationDependencies}, which takes the same
 * approach but with a subclass rather than a superclass.
 *
 * <p>TODO(cpovirk): Consider applying this subclass approach to our other types.
 */
@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
@GwtCompatible(emulated = true)

 * supersource for this class contains a field of type {@code C}.
 *
 * <p>For details about this hack, see {@code GwtSerializationDependencies}, which takes the same
 * approach but with a subclass rather than a superclass.
 *
 * <p>TODO(cpovirk): Consider applying this subclass approach to our other types.
 */
@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
@GwtCompatible(emulated = true)

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

//go:build netgo && netcgo

package net

func init() {
	// This will give a compile time error about the unused constant.
	// The advantage of this approach is that the gc compiler
	// actually prints the constant, making the problem obvious.
	"Do not use both netgo and netcgo build tags."

	// 	doesn't provide any ways to retrieve the current TCP keep-alive settings, therefore
	// 	we're not able to run the test suite similar to Unix-like OS's on Windows.
	//  Try to find another proper approach to test the keep-alive settings on old Windows.
	if !windows.SupportTCPKeepAliveIdle() || !windows.SupportTCPKeepAliveInterval() || !windows.SupportTCPKeepAliveCount() {
		t.Skip("skipping on windows")
	}

For now we just have this global repository of ADRs.
If we see fit, we can break these out to per-platform ones, or keep a hybrid approach to having global and platform-specific ADSs.

Our aim is to keep the process lightweight and approachable.

        // Configures the majority of the infrastructure required for resolving dependencies.
        // This is the dependency-injection-less approach to obtain a `RepositorySystem`.
        // Maven generally recommends using Eclipse Sisu and Guice for DI, however this approach is also supported.
        RepositorySystem repoSystem = new RepositorySystemSupplier().get()

dialects and utilities for

1. TensorFlow
2. XLA
3. TF Lite

See [MLIR's website](https://mlir.llvm.org) for complete documentation.

## Getting started

Building dialects and utilities here follow the standard approach using
`bazel` as the rest of TensorFlow.

### Using local LLVM repo

To develop across MLIR core and TensorFlow, it is useful to override the repo to

This program, dist, is the bootstrapping tool for the Go distribution.

As of Go 1.5, dist and other parts of the compiler toolchain are written
in Go, making bootstrapping a little more involved than in the past.
The approach is to build the current release of Go with an earlier one.

The process to install Go 1.x, for x ≥ 22, is:

1. Build cmd/dist with Go 1.20.6.
2. Using dist, build Go 1.x compiler toolchain with Go 1.20.6.

// even in simple programs like gofmt when they parallelize walking
// a file tree.
//
// After a long discussion on go.dev/issue/46279, we decided the
// best approach was for Go to raise the limit unconditionally for itself,
// and then leave old software to set the limit back as needed.
// Code that really wants Go to leave the limit alone can set the hard limit,

// that serves the (non-HTTP) 'svn' protocol. The test binary can retrieve the
// URL for that port by sending an HTTP request with the query parameter
// "vcwebsvn=1".
//
// We take this approach because the 'svn' protocol is implemented by a
// lightweight 'svnserve' binary that is usually packaged along with the 'svn'
// client binary, whereas only known implementation of the Subversion HTTP