Michael Anthony Knyszek <******@****.***> 1716583527 +0000

Carlos Amedee <******@****.***> 1715265901 -0400

// compiledir

// Copyright 2013 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.

// Issue 5125: cyclic dependencies between types confuse
// the hashability test during import.

// compile

// Copyright 2014 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.

// issue 8761
// used to confuse code generator into using temporary before initialization.
// caused 'variable live at entry' error in liveness analysis.

package p

func f1() {
	type C chan int
	_ = [1][]C{[]C{make(chan int)}}
}

func f2() {

// Test cases for symbol name mangling.

package main

import (
	"fmt"
	"strings"
)

// Issue 58800:
// Instantiated function name may contain weird characters
// that confuse the external linker, so it needs to be
// mangled.
type S struct {
	X int `parser:"|@@)"`
}

//go:noinline
func F[T any]() {}

func P() {
	F[S]()
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

// Setting an environment variable in a cgo program changes the C
// environment. Test that this does not confuse the race detector.

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread
*/
import "C"

import (
	"fmt"
	"os"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup

// run

// Copyright 2016 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.

// issue 16948: make sure intrinsified atomic ops won't
// confuse the scheduler.

package main

import "sync/atomic"

func main() {
	f()
}

var x int32

type T [10]int
var sink *T

func f() (t T) {
	atomic.AddInt32(&x, 1)

// run

// Copyright 2012 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.

// The no-op conversion here used to confuse the compiler
// into doing a load-effective-address of nil.
// See issue 3670.

package main

import "reflect"

type T interface {}

var x bool

func main() {
        reflect.TypeOf(nil)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that s[len(s):] - which can point past the end of the allocated block -
// does not confuse the garbage collector.

package main

import (
	"runtime"
	"time"
)

type T struct {
	ptr **int
	pad [120]byte
}

var things []interface{}

func main() {
	setup()

namespace mlir::quant::stablehlo {

// Introduces aliases for `std::string` to distinguish btw. function name and
// its alias, to prevent confusion when used together in a container. For
// example, it is easy to confuse function name -> alias mapping with alias ->
// function name mapping when both are just represented as `std::string`.
using FunctionAlias = std::string;
using FunctionName = std::string;