}
var comparableTypes = []namedCELType{
	{typeName: "int", celType: cel.IntType},
	{typeName: "uint", celType: cel.UintType},
	{typeName: "double", celType: cel.DoubleType},
	{typeName: "bool", celType: cel.BoolType},
	{typeName: "duration", celType: cel.DurationType},
	{typeName: "timestamp", celType: cel.TimestampType},
	{typeName: "string", celType: cel.StringType},
	{typeName: "bytes", celType: cel.BytesType},
}

        TypeName implementationOwner = TypeUtils.typeName(request.getImplementationInfo().getOwner());
        String implementationName = request.getImplementationInfo().getName();
        if (request.getInterceptedCallable().getKind() == CallableKindInfo.AFTER_CONSTRUCTOR) {

            return "@" + ReflectionUtils.getDisplayName(annotationType);
        }
        String typeName = annotationType.getName();
        String str = annotation.toString();
        return str.startsWith("@" + typeName)
                ? "@" + ReflectionUtils.getDisplayName(annotationType) + str.substring(typeName.length() + 1)
                : str;
    }

    public static String getDisplayString(Object object) {

			return
		}
		arg := call.Args[0]

		// Retrieve target type name.
		var tname *types.TypeName
		switch fun := call.Fun.(type) {
		case *ast.Ident:
			tname, _ = pass.TypesInfo.Uses[fun].(*types.TypeName)
		case *ast.SelectorExpr:
			tname, _ = pass.TypesInfo.Uses[fun.Sel].(*types.TypeName)
		}
		if tname == nil {
			return
		}

// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
// type.  This can be used as a compile-time assertion to ensure that
// two types are equal.

template <typename T1, typename T2>
struct AssertTypeEq;

template <typename T>
struct AssertTypeEq<T, T> {
  typedef bool type;
};

// A unique type used as the default value for the arguments of class

#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "tfrt/basic_kernels/opdefs/types.h"  // from @tf_runtime

namespace tfrt {
namespace fallback_common {

template <typename OpTy>
mlir::LogicalResult VerifyExecuteOpCommon(OpTy op) {
  auto op_attr_array = op.getOpAttrs().getValue();
  for (auto op_attr : op_attr_array) {
    auto key_value = mlir::dyn_cast<mlir::ArrayAttr>(op_attr);

            ? CodeBlock.of("receiverClass")
            : CodeBlock.of("arg$L", paramIndex);

        int childArgCount = paramIndex + 1;
        TypeName entryChildType = TypeUtils.typeName(entry.type);
        CodeBlock matchExpr = entry.kind == RECEIVER_AS_CLASS ?
            CodeBlock.of("isStatic && $T.class.isAssignableFrom($L)", entryChildType.box(), argExpr) :

func (*Alias) Underlying() types.Type { panic("unreachable") }
func (*Alias) Obj() *types.TypeName   { panic("unreachable") }
func Rhs(alias *Alias) types.Type     { panic("unreachable") }

// Unalias returns the type t for go <=1.21.
func Unalias(t types.Type) types.Type { return t }

func newAlias(name *types.TypeName, rhs types.Type) *Alias { panic("unreachable") }

// Find the first op with any of the specified types on each path rooted at the
// `root` node in a tree. Additional checks can be applied via `predicate`. The
// results are stored in `ops`.
template <typename T, typename... Types>
LogicalResult GetFirstOpsOfType(
    func::FuncOp root, SymbolTable &symtab,
    const std::function<bool(SymbolUserOpInterface)> &predicate,
    llvm::SmallVector<SymbolUserOpInterface> &ops) {

    }

    private static synchronized String guessLanguageName(String typeName) {
        String language = LANGUAGES.get(typeName);
        if (language != null) {
            return language;
        }
        language = typeName.replaceAll("LanguageSourceSet$", "").replaceAll("SourceSet$", "").replaceAll("Source$", "").replaceAll("Set$", "");
        LANGUAGES.put(typeName, language);
        return language;
    }

    @Override