ExtensionReceiver[name: dumbWith; isMutated: false; displayText: this@dumbWith]
    dumbWith@fun R|kotlin/Any?|.<anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>
    R|kotlin/Any?|
ExtensionReceiver[name: dumbWith; isMutated: false; displayText: this@dumbWith]
    dumbWith@fun R|kotlin/Any?|.<anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>

const truth = true

func f() int { // ERROR "can inline f"
	if truth {
		return 0
	}
	// If everything below is removed, as it should,
	// function f should be inlineable.
	nonleaf()
	for {
		panic("")
	}
}

func g() int { // ERROR "can inline g"
	return f() // ERROR "inlining call to f"
}

func f2() int { // ERROR "can inline f2"
	if !truth {
		nonleaf()
	} else {
		return 0
	}

import org.gradle.internal.service.ServiceRegistry


internal
inline fun <reified T : Any> TaskInternal.serviceOf(): T =
    project.serviceOf()


inline fun <reified T : Any> Project.serviceOf(): T =
    (this as ProjectInternal).services.get()


inline fun <reified T : Any> GradleInternal.serviceOf(): T =
    services.get()


inline fun <reified T : Any> ServiceRegistry.get(): T =

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

func F() { // ERROR "can inline F"
	g(0) // ERROR "inlining call to g\[go.shape.int\]"
}

 * @see [ExtensionContainer.getByType]
 * @since 5.0
 */
inline fun <reified T : Any> ExtensionContainer.getByType(): T =
    getByType(typeOf<T>())


/**
 * Looks for the extension of a given type.
 *
 * @param T the extension type
 * @return the extension or null if not found
 *
 * @see [ExtensionContainer.findByType]
 * @since 5.0
 */
inline fun <reified T : Any> ExtensionContainer.findByType(): T? =

 */
internal object Locks {
  inline fun <T> Dispatcher.withLock(action: () -> T): T {
    contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
    return lock.withLock(action)
  }

  inline fun <T> RealConnection.withLock(action: () -> T): T {
    contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
    return lock.withLock(action)
  }

  inline fun <T> RealCall.withLock(action: () -> T): T {

func small5() { // ERROR "can inline small5"
	// the Unlock fast path should be inlined
	mutex.Unlock() // ERROR "inlining call to sync\.\(\*Mutex\)\.Unlock"
}

func small6() { // ERROR "can inline small6"
	// the Lock fast path should be inlined
	mutex.Lock() // ERROR "inlining call to sync\.\(\*Mutex\)\.Lock"
}

var once *sync.Once

func small7() { // ERROR "can inline small7"
	// the Do fast path should be inlined

    final override val contextReceivers: List<KaContextReceiver> get() = withValidityAssertion { emptyList() }

    public abstract val isDefault: Boolean
    public abstract val isInline: Boolean
    public abstract val isOverride: Boolean
    public abstract val hasBody: Boolean

    final override val symbolKind: KaSymbolKind get() = withValidityAssertion { KaSymbolKind.ACCESSOR }

  inline cpp_impl *unwrap(wrapper *w) {                                        \
    return reinterpret_cast<cpp_impl *>(w);                                    \
  }                                                                            \
                                                                               \
  inline const cpp_impl *unwrap(const wrapper *w) {                            \

type Simple struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`
	// +optional
	Other string `json:"other,omitempty"`
	// +optional
	Labels map[string]string `json:"labels,omitempty"`
}

// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object

type SimpleRoot struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`
	// +optional