zirain <******@****.***> 1718030161 +0800

// CHECK-LABEL test_tpu_execute
func.func @test_tpu_execute(%arg0: tensor<!tf_type.string>) {
     %0 = builtin.unrealized_conversion_cast to tensor<2048xi32>
     %1 = builtin.unrealized_conversion_cast to tensor<2048xi32>
     %2 = builtin.unrealized_conversion_cast to tensor<i32>
     %3 = builtin.unrealized_conversion_cast to tensor<i32>
     // CHECK: TPUCopyWithDynamicShape{{.*}}device = "foobar"

	tests := []struct {
		name      string
		namespace string
		want      string
	}{
		{"foo", "ns", "kubernetes-gateway://ns/foo"},
		{"builtin://", "anything", "builtin://"},
		{"builtin://extra", "anything", "builtin://"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := ToKubernetesGatewayResource(tt.namespace, tt.name); got != tt.want {

#include "tensorflow/compiler/mlir/lite/schema/schema_generated.h"

namespace tflite {

// The following methods are introduced to resolve op builtin code shortage
// problem. The new builtin operator will be assigned to the extended builtin
// code field in the flatbuffer schema. Those methods helps to hide builtin code
// details.
BuiltinOperator GetBuiltinCode(const OperatorCode *op_code);

BuiltinOperator GetBuiltinCode(const OperatorCodeT *op_code);

# (Though we can't try installing it without modifying goroot).
env GODEBUG=installgoroot=all
go list -f '{{.Target}}' fmt
stdout fmt\.a

# However, the fake packages "builtin" and "unsafe" do not.
go list -f '{{.Target}}' builtin unsafe
! stdout .
go install builtin unsafe  # Should succeed as no-ops.

# With CGO_ENABLED=0, packages that would have
# an install target with cgo on no longer do.
env GODEBUG=
env CGO_ENABLED=0

// The actual builtin operator code value will exist in the
// `deprecated_builtin_code` field. At the same time, it implies that
// `deprecated_builtin_code` >= `builtin_code` and the maximum value of the two
// fields will be same with `deprecated_builtin_code'.
//
// - Supporting builtin operator codes beyonds 127
//
// New builtin operators, whose operator code is larger than 127, can not be

{{- end}}
)

func create(c kube.Client, cfg config.Config, objMeta metav1.ObjectMeta) (metav1.Object, error) {
	switch cfg.GroupVersionKind {
{{- range .Entries }}
	{{- if and (not .Resource.Synthetic) (not .Resource.Builtin) }}
	case gvk.{{.Resource.Identifier}}:

			{{- if ne "" .Resource.StatusProtoPackage}}StatusPackage: "{{ .Resource.StatusProtoPackage }}", {{end}}
			ClusterScoped: {{ .Resource.ClusterScoped }},
			Synthetic: {{ .Resource.Synthetic }},
			Builtin: {{ .Resource.Builtin }},
			ValidateProto: {{ .Resource.Validate }},
		}.MustBuild()
{{ end }}

	// All contains all collections in the system.
	All = collection.NewSchemasBuilder().
	{{- range .Entries }}

	// ClusterScoped is true for resource in cluster-level.
	ClusterScoped bool

	// Synthetic is true for resource that do not actually exist in a cluster
	Synthetic bool

	// Builtin is true for resources that are builtin (not CRD)
	Builtin bool

	// Identifier is the unique identifier for the resource
	Identifier string

	// Kind is the config proto type.
	Kind string

	// Plural is the type in plural.

//go:build ignore

// Generate builtin.go from builtin/runtime.go.

package main

import (
	"bytes"
	"flag"
	"fmt"
	"go/ast"
	"go/format"
	"go/parser"
	"go/token"
	"io"
	"log"
	"os"
	"path/filepath"
	"strconv"
	"strings"
)

var stdout = flag.Bool("stdout", false, "write to stdout instead of builtin.go")