* 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)) {

// clang -gdwarf-5 -O2 -nostdlib

__attribute__((noinline, cold))
static int sum(int i) {
  int j, s;

  s = 0;
  for (j = 0; j < i; j++) {
    s += j * i;
  }
  return s;
}

int main(int argc, char** argv) {
  if (argc == 0) {
    return 0;
  }
  return sum(argc);

// gcc -g -O2 -freorder-blocks-and-partition

const char *arr[10000];
const char *hot = "hot";
const char *cold = "cold";

__attribute__((noinline))
void fn(int path) {
	int i;

	if (path) {
		for (i = 0; i < sizeof arr / sizeof arr[0]; i++) {
			arr[i] = hot;
		}
	} else {
		for (i = 0; i < sizeof arr / sizeof arr[0]; i++) {
			arr[i] = cold;
		}
	}
}

int main(int argc, char *argv[]) {
	fn(argc);
	return 0;

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type Value[T any] struct {
	val T
}

// The noinline directive should survive across import, and prevent instantiations
// of these functions from being inlined.

//go:noinline
func Get[T any](v *Value[T]) T {
	return v.val
}

//go:noinline

# can be trimmed like subdirectory paths are.

env GOEXPERIMENT=loopvar
go build -gcflags=inlines/a=-d=loopvar=2 .
stderr ^\.[\\/]b[\\/]b\.go:12:6:.*loop.inlined.into.a[\\/]a\.go
stderr ^\.[\\/]b[\\/]b\.go:12:9:.*loop.inlined.into.a[\\/]a\.go

-- go.mod --
module inlines

go 1.21
-- a/a.go --
// Copyright 2023 The Go Authors. All rights reserved.

  func.func private @some_func(%arg0: tensor<1x2x2x3xf32>) -> tensor<1x2x2x3xf32> attributes {tf._noinline = true} {
    return %arg0 : tensor<1x2x2x3xf32>
  }

  // CHECK-SKIP: func.func private @some_other_func
  func.func private @some_other_func(%arg0: tensor<1x2x2x3xf32>) -> tensor<1x2x2x3xf32> attributes {tf._noinline = true} {
    return %arg0 : tensor<1x2x2x3xf32>
  }

        if (errors.size() > 0) {
            throw new MetaDataParseException(
                    String.format("inconsistent module metadata found. Descriptor: %s Errors: %s", actualId, joinLines(errors)));
        }
    }

    private String joinLines(List<String> lines) {
        return Joiner.on(SystemProperties.getInstance().getLineSeparator()).join(lines);
    }

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) =

// Check that we only outline the outermost partitioned call with
// `_xla_compile_device_type` in nested calls to a device cluster. The callee
// of any partitioned call outside of a device cluster is marked with
// `tf._noinline = true` to prevent it getting inlined to perseve runtime
// performance.
// CHECK-LABEL: func.func @nested_calls
func.func @nested_calls(%arg0: tensor<i32>) -> tensor<i32> attributes {tf.entry_function = {}} {

  func.return %1 : tensor<i32>
}

func.func private @xla_func_0(%arg0: tensor<1x3xf32>, %arg1: tensor<1x3xf32>) -> tensor<1x3xf32> attributes {tf._XlaMustCompile = true, tf._noinline = true, tf._original_func_name = "should_not_be_used"} {
  %1 = "tf.AddV2"(%arg0, %arg1) : (tensor<1x3xf32>, tensor<1x3xf32>) -> tensor<1x3xf32>
  %2 = "tf.Const"() {value = dense<0> : tensor<i32>} : () -> tensor<i32>