// (idealized) memory profile of a TFLite graph and simulate the effect of
// re-inserting operations on that memory profile.

#include <algorithm>
#include <cinttypes>
#include <tuple>
#include <vector>

namespace mlir {
namespace TFL {

// A class that
// (1) Encodes in concise form the memory requirements of a computational graph

type namedCELType struct {
	typeName string
	celType  *cel.Type
}

var summableTypes = []namedCELType{
	{typeName: "int", celType: cel.IntType},
	{typeName: "uint", celType: cel.UintType},
	{typeName: "double", celType: cel.DoubleType},
	{typeName: "duration", celType: cel.DurationType},
}

var zeroValuesOfSummableTypes = map[string]ref.Val{
	"int":      types.Int(0),

	case cel.DurationType:
		return apiservercel.DurationType
	case cel.IntType:
		return apiservercel.IntType
	case cel.NullType:
		return apiservercel.NullType
	case cel.StringType:
		return apiservercel.StringType
	case cel.TimestampType:
		return apiservercel.TimestampType
	case cel.UintType:
		return apiservercel.UintType
	default:

		return DoubleType
	case DurationType.TypeName():
		return DurationType
	case IntType.TypeName():
		return IntType
	case NullType.TypeName():
		return NullType
	case StringType.TypeName():
		return StringType
	case TimestampType.TypeName():
		return TimestampType
	case UintType.TypeName():
		return UintType
	case ListType.TypeName():
		return ListType
	case MapType.TypeName():
		return MapType

type CharType struct {
	BasicType
}

// A UcharType represents an unsigned character type.
type UcharType struct {
	BasicType
}

// An IntType represents a signed integer type.
type IntType struct {
	BasicType
}

// A UintType represents an unsigned integer type.
type UintType struct {
	BasicType
}

// A FloatType represents a floating point type.
type FloatType struct {
	BasicType
}

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

// Issue 2231

package main
import "runtime"

func foo(runtime.UintType, i int) {  // ERROR "cannot declare name runtime.UintType|mixed named and unnamed|undefined identifier"
	println(i, runtime.UintType) // GCCGO_ERROR "undefined identifier"
}

func qux() {
	var main.i	// ERROR "unexpected [.]|expected type"
	println(main.i)
}

func corge() {

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

// Issue 2231

package main
import "runtime"

func bar(i int) {
	runtime.UintType := i       // ERROR "non-name runtime.UintType|non-name on left side|undefined"
	println(runtime.UintType)	// ERROR "invalid use of type|undefined"
}

func baz() {
	main.i := 1	// ERROR "non-name main.i|non-name on left side|undefined"

	var testData = []struct {
		arch    string
		intType string
		ok      bool
	}{
		{"arm64", "int32", true},
		{"amd64", "int32", true},
		{"amd64", "int8", false},
	}

	for _, data := range testData {
		t.Run(data.arch+"/"+data.intType, func(t *testing.T) {
			c := testConfigArch(t, data.arch)
			boolType := c.config.Types.Bool
			var intType *types.Type
			switch data.intType {
			case "int32":

// 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 issue30527

import "math"

/*
#include <inttypes.h>

static void issue30527F(char **p, uint64_t mod, uint32_t unused) {}
*/
import "C"

func G(p **C.char) {
	C.issue30527F(p, math.MaxUint64, 1)
	C.issue30527F(p, 1<<64-1, Z)

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

package p

type FooType[t any] interface {
	Foo(BarType[t])
}
type BarType[t any] interface {
	Int(IntType[t]) FooType[int]
}

type IntType[t any] int

func (n IntType[t]) Foo(BarType[t]) {}