#include "tsl/platform/regexp.h"

using llvm::LessRecord;
using llvm::raw_ostream;
using llvm::Record;
using llvm::RecordKeeper;
using mlir::tblgen::Operator;

enum class InputDataType { INT8, UINT8, INT16 };

// One InputDataType will be likely mapped to multiple types in near future so
// the two structures are separated.
const std::map<std::string, std::string> &GetTypeToStringRepresentation() {

}

// icast casts a signed int to the size in s
func icast(i int64, s sizedTestData) int64 {
	switch s.name {
	case "int32":
		return int64(int32(i))
	case "int16":
		return int64(int16(i))
	case "int8":
		return int64(int8(i))
	}
	return i
}

type sizedTestData struct {
	name string
	sn   string
	u    []uint64
	i    []int64
}

package main

// Test ensures that abi information producer and consumer agree about the
// order of registers for inputs.  T's registers should be I0, F0, I1, F1.

import "fmt"

type P struct {
	a int8
	x float64
}

type T struct {
	d, e P
}

//go:registerparams
//go:noinline
func G(t T) float64 {
	return float64(t.d.a+t.e.a) + t.d.x + t.e.x
}

func main() {

}

// test case from issue

type FloatType { // ERRORx "expected type|type declaration"
	float32 | float64
} // ERRORx "expected declaration|non-declaration statement"

type IntegerType interface {
	int8 | int16 | int32 | int64 | int |
		uint8 | uint16 | uint32 | uint64 | uint
}

type ComplexType interface {
	complex64 | complex128
}

type Number interface {
	FloatType | IntegerType | ComplexType
}

	v11 = xx/yy*yy - xx
	v12 = true && false
	v13 = nil /* ERROR "use of untyped nil" */
	v14 string = 257 // ERRORx `cannot use 257 .* as string value in variable declaration$`
	v15 int8 = 257 // ERRORx `cannot use 257 .* as int8 value in variable declaration .*overflows`
)

// Multiple assignment expressions
var (
	m1a, m1b = 1, 2
	m2a, m2b, m2c /* ERROR "missing init expr for m2c" */ = 1, 2

	return d&(d-1) != 0
}

// umagicOKn reports whether we should strength reduce an unsigned n-bit divide by c.
// We can strength reduce when c != 0 and c is not a power of two.
func umagicOK8(c int8) bool   { return c&(c-1) != 0 }
func umagicOK16(c int16) bool { return c&(c-1) != 0 }
func umagicOK32(c int32) bool { return c&(c-1) != 0 }
func umagicOK64(c int64) bool { return c&(c-1) != 0 }

type umagicData struct {

	swt(v1, 1)
	swt(v2, 2)
}

//go:noinline
func swt(i interface{}, want int) {
	var got int
	switch i.(type) {
	case *ssa1.T:
		got = 1
	case *ssa2.T:
		got = 2

	case int8, int16, int32, int64:
		got = 3
	case uint8, uint16, uint32, uint64:
		got = 4
	}

	if got != want {
		panic(fmt.Sprintf("switch %v: got %d, want %d", i, got, want))
	}

// once tried to do the load in f twice, once sign extended
// and once zero extended.  This can cause problems in
// racy code, particularly sync/mutex.

package main

func f(p *byte) bool {
	x := *p
	a := int64(int8(x))
	b := int64(uint8(x))
	return a == b
}

func main() {
	var x byte
	const N = 1000000
	c := make(chan struct{})
	go func() {
		for i := 0; i < N; i++ {
			x = 1
		}
		c <- struct{}{}
	}()

package main

import (
	"fmt"
	"os"
)

type big struct {
	pile [768]int8
}

type thing struct {
	name  string
	next  *thing
	self  *thing
	stuff []big
}

func test(t *thing, u *thing) {
	if t.next != nil {
		return
	}
	fmt.Fprintf(os.Stderr, "%s\n", t.name)
	u.self = u
	t.self = t
	t.next = u
	for _, p := range t.stuff {
		if isFoo(t, p) {
			return
		}
	}
}

	default:
		fmt.Println("other", x)
	}
}
func main() {
	f[float64](float64(6))
	f[float64](int(7))
	f[float64](int32(8))
	f[float64](struct{ a, b float64 }{a: 1, b: 2})
	f[float64](int8(9))
	f[int32](int32(7))
	f[int](int32(7))
	f[any](int(10))
	f[interface{ M() }](int(11))