// removed by resource lifting. Requires known maximum sizes of stacks and
// known element shapes of push ops.
std::unique_ptr<OperationPass<ModuleOp>> CreateStackOpsDecompositionPass();

// Creates a pass to strip the "tf._noinline" attribute from the functions in
// the module.
std::unique_ptr<OperationPass<ModuleOp>> CreateStripNoinlineAttributePass();

// Converts tensor list operations into operations on buffers and sizes. Needs

  FunctionDef noinline = compilable;
  noinline.mutable_signature()->set_name("NoInlineFn");
  AddAttr("_noinline", static_cast<bool>(true), noinline.mutable_attr());

  FunctionDefLibrary flib;
  *flib.add_function() = compilable;
  *flib.add_function() = uncompilable;
  *flib.add_function() = noinline;
  FunctionLibraryDefinition flib_def(OpRegistry::Global(), flib);

  ];
}

def StripNoinlineAttributePass : Pass<"tf-strip-noinline-attribute", "ModuleOp"> {
  let summary = "Strip the tf._noinline attribute from top-level functions.";
  let constructor = "TF::CreateStripNoinlineAttributePass()";
}

  %pop_result = "tf.Reshape"(%slice, %elem_size_const)
  "tf.AssignVariableOp"(%size, %new_size)
```

The pass also works across control flow and functional calls.
### `-tf-strip-noinline-attribute`

_Strip the tf._noinline attribute from top-level functions._

### `-tf-strip-tf-attributes`

_Removes TF specific attributes_

Removes attributes that are TF specific (start with "tf.") or that

		}

		match := func(n ir.Node) bool {
			switch n := n.(type) {
			case *ir.CallExpr:
				return true
			case *ir.TailCallStmt:
				n.Call.NoInline = true // can't inline yet
			}
			return false
		}

		edit := func(n ir.Node) ir.Node {
			call, ok := n.(*ir.CallExpr)
			if !ok { // previously inlined
				return nil
			}

     * Processes the descendants of the element using the preorder implementation of tree traversal.
     */
    private inline fun <reified T : PsiElement> PsiElement.forEachDescendantOfType(
        noinline predicate: (T) -> Boolean = { true },
        noinline action: (T) -> Unit,
    ) = this.accept(object : PsiRecursiveElementVisitor() {
        override fun visitElement(element: PsiElement) {
            if (element is T && predicate(element)) {

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

    /**
     * Returns true if the function parameter is marked with `noinline` modifier
     */
    public abstract val isNoinline: Boolean

    /**
     * Returns true if the function parameter is marked with `crossinline` modifier
     */
    public abstract val isCrossinline: Boolean

import org.gradle.vcs.VersionControlSpec


/**
 * Specifies the VCS location for the requested component.
 *
 * @see VcsMapping.from
 */
inline fun <reified T : VersionControlSpec> VcsMapping.from(noinline configureAction: T.() -> Unit) =

 *
 * @see [PolymorphicDomainObjectContainer.register]
 */
inline fun <reified T : Any> PolymorphicDomainObjectContainer<in T>.register(name: String, noinline configuration: T.() -> Unit): NamedDomainObjectProvider<T> =
    register(name, T::class.java, configuration)


/**
 * Creates a domain object with the specified name and type, adds it to the container,

		cfg.Granularity = "addresses"
		cfg.NoInlines = false // Need inline info to support call expansion
	case "peek":
		trim = false
	case "list":
		trim = false
		cfg.Granularity = "lines"
		// Do not force 'noinlines' to be false so that specifying
		// "-list foo -noinlines" is supported and works as expected.
	case "text", "top", "topproto":
		if cfg.NodeCount == -1 {
			cfg.NodeCount = 0
		}
	default: