Matthew Dempsky <******@****.***> 1651619260 -0700

var _ = &Pointer[int]{}

// A Pointer is an atomic pointer of type *T. The zero value is a nil *T.
type Pointer[T any] struct {
	// Mention *T in a field to disallow conversion between Pointer types.
	// See go.dev/issue/56603 for more details.
	// Use *T, not T, to avoid spurious recursive type definition errors.
	_ [0]*T

	_ noCopy
	v unsafe.Pointer
}

import org.objectweb.asm.Type;

import javax.lang.model.element.ExecutableElement;
import javax.lang.model.type.TypeMirror;

public class TypeUtils {
    public static Type extractType(TypeMirror typeMirror) {
        return typeMirror.accept(new TypeMirrorToType(), null);
    }

    public static Type extractReturnType(ExecutableElement methodElement) {

' Boundaries
' ##################################

!define Boundary(e_alias, e_label) rectangle "==e_label" <<boundary>> as e_alias
!define Boundary(e_alias, e_label, e_type) rectangle "==e_label [e_type]" <<boundary>> as e_alias

' Relationship
' ##################################

!define Rel_(e_alias1, e_alias2, e_label, e_direction="") e_alias1 e_direction e_alias2 : "===e_label"

	}

	found := false
	returnTypes := expressionAccessor.ReturnTypes()
	for _, returnType := range returnTypes {
		if ast.OutputType() == returnType || cel.AnyType == returnType {
			found = true
			break
		}
	}
	if !found {
		var reason string
		if len(returnTypes) == 1 {
			reason = fmt.Sprintf("must evaluate to %v", returnTypes[0].String())
		} else {

        1. Set _name = "MatMul"
        2. For each TF attribute, split it into two attributes, one for name of
           the TF attribute, and the other for the type and value of the
           attribute value. Attribute value is a string with the format of
           "type$val", where type can be "bool", "string", "tfdtype", "tfshape",
           "tftensor".
           The value serialization format can be found in attr_util.h.

func (v *ExtraMappingExpression) ReturnTypes() []*celgo.Type {
	// return types is only used for validation. The claims variable that's available
	// to the claim mapping expressions is a map[string]interface{}, so we can't
	// really know what the return type is during compilation. Strict type checking
	// is done during evaluation.
	return []*celgo.Type{celgo.AnyType}
}

var _ ExpressionAccessor = &UserValidationCondition{}

			// underlying; if the underlying type is unrestricted there must be an
			// element of the type set that violates one of the arg type checks
			// below, so we can safely return false here.

			if m.t == anyType { // anyType must have already been handled.
				panic("unexpected printfArgType")
			}
			return false
		}

		// Only report a reason if typ is the argument type, otherwise it won't

        MethodHandle spreader = original.asSpreader(Object[].class, original.type().parameterCount());
        MethodHandle decorated = MethodHandles.insertArguments(INTERCEPTOR, 0, this, spreader, flags, caller.lookupClass().getName());
        return decorated.asCollector(Object[].class, original.type().parameterCount()).asType(original.type());
    }

	return common.NewObjectVal(r, fields)
}

// CELType returns the type. The returned type is of TypeType type.
func (r *TypeRef) CELType() *types.Type {
	return r.celTypeType
}

// Field looks up the field by name.
// This is the unstructured version that allows any name as the field name.
// The returned field is of DynType type.
func (r *TypeRef) Field(name string) (*types.FieldType, bool) {