override val isDefault: Boolean
        get() = withValidityAssertion { descriptor.isDefault }

    override val isInline: Boolean
        get() = withValidityAssertion { descriptor.isInline }

    override val isOverride: Boolean
        get() = withValidityAssertion { descriptor.isExplicitOverride }

    override val hasBody: Boolean

	if f == nil {
		return ""
	}
	fn := f.raw()
	if fn.isInlined() { // inlined version
		fi := (*funcinl)(unsafe.Pointer(fn))
		return funcNameForPrint(fi.name)
	}
	return funcNameForPrint(funcname(f.funcInfo()))
}

// Entry returns the entry address of the function.
func (f *Func) Entry() uintptr {
	fn := f.raw()
	if fn.isInlined() { // inlined version
		fi := (*funcinl)(unsafe.Pointer(fn))

		}
	}

	{
		a := 2
		if r := func(x int) int { // ERROR "can inline main.func28"
			b := 3
			return func(y int) int { // ERROR "can inline main.func28.1" "can inline main.main.func28.func35"
				c := 5
				func(z int) { // ERROR "can inline main.func28.1.1" "can inline main.func28.main.func28.1.2" "can inline main.main.func28.func35.1" "can inline main.main.func28.main.main.func28.func35.func37"
					a = a * x
					b = b * y

inline constexpr char kSavedModelLegacyInitOpKey[] = "legacy_init_op";

/// SavedModel main op collection key. Used in v1 SavedModels.
inline constexpr char kSavedModelMainOpKey[] = "saved_model_main_op";

// CollectionDef key for the SavedModel train op.
// Not exported while export_all_saved_models is experimental.
inline constexpr char kSavedModelTrainOpKey[] = "saved_model_train_op";

// Schema version for SavedModel.

	return func() int { return 42 }() // ERROR "can inline p.func1" "inlining call to p.func1"
}

func q(x int) int { // ERROR "can inline q"
	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
	return foo()                       // ERROR "inlining call to q.func1"
}

func r(z int) int { // ERROR "can inline r"

                if (symbol is KaFunctionSymbol) {
                    if (symbol.isExternal) add(KtTokens.EXTERNAL_KEYWORD)
                    if (symbol.isOverride) add(KtTokens.OVERRIDE_KEYWORD)
                    if (symbol.isInline) add(KtTokens.INLINE_KEYWORD)
                    if (symbol.isInfix) add(KtTokens.INFIX_KEYWORD)
                    if (symbol.isOperator) add(KtTokens.OPERATOR_KEYWORD)

GO PREPROFILE V1
example.com/pgo/inline.A
example.com/pgo/inline.(*BS).NS
7 129
example.com/pgo/inline.(*BS).NS
example.com/pgo/inline.T
8 3
example.com/pgo/inline.(*BS).NS
example.com/pgo/inline.T
13 2
example.com/pgo/inline.benchmarkB
example.com/pgo/inline.A

inline const char kMlirPh1BridgeCounterV1[] = "v1";
inline const char kMlirPh1BridgeCounterV2[] = "v2";
inline const char kMlirPh1BridgeCounterTpu[] = "tpu";
inline const char kMlirPh1BridgeCounterNonTpu[] = "cpu/gpu";
inline const char kXlaOutsideCompilation[] = "_xla_outside_compilation";

// Copies attributes that satisfy the given predicate from `from` to `to`.
template <typename Predicate>

	f = func() { // ERROR "func literal escapes to heap" "can inline f1.func2"
		p = alloc(3) // ERROR "inlining call to alloc" "moved to heap: x"
	}
	f()
}

func f2() {} // ERROR "can inline f2"

// No inline for recover; panic now allowed to inline.
func f3() { panic(1) } // ERROR "can inline f3" "1 escapes to heap"
func f4() { recover() }

func f5() *byte { // ERROR "can inline f5"
	type T struct {
		x [1]byte
	}

	if !reflect.DeepEqual(got, expected) {
		t.Errorf("split(%q): got %q expected %q", inLine, got, expected)
	}

	// Try another undefined variable as an extra check
	os.Unsetenv("_Z")
	inLine = "//go:generate -command CMD1 \"ab${_Z}cd\""
	expected = []string{"-command", "CMD1", "abcd"}
	got = g.split(inLine + "\n")

	if !reflect.DeepEqual(got, expected) {