Name AST
	Type AST
}

func (t *Typed) print(ps *printState) {
	// We are printing a typed name, so ignore the current set of
	// inner names to print.  Pass down our name as the one to use.
	holdInner := ps.inner
	defer func() { ps.inner = holdInner }()

	ps.inner = []AST{t}
	ps.print(t.Type)
	if len(ps.inner) > 0 {
		// The type did not print the name; print it now in
		// the default location.

                    allSuperTypes.print("[all super types]")
                    approximatedAllSuperTypes.print("[approximated all super types]")
                }
            }
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

            })

            tasks.register("print") {
                doLast {
                    ciVars.get().forEach((k, v) -> {
                        println("Execution: \$k = \$v")
                    })
                }
            }
        """)

        when:
        EnvVariableInjection.environmentVariable("CI1", "1").setup(this)
        configurationCacheRun("print")

        then:

internal
fun FlyweightCapableTreeStructure<LighterASTNode>.print(
    node: LighterASTNode = root,
    indent: String = ""
) {
    val ref = Ref<Array<LighterASTNode?>>()

    getChildren(node, ref)
    val kidsArray = ref.get() ?: return

    for (kid in kidsArray) {
        if (kid == null) break
        kid.print(indent)
        print(kid, "\t$indent")
    }
}


internal

    - sync: synchronization blocking profile
    - syscall: syscall blocking profile
    - sched: scheduler latency profile

Flags:
	-http=addr: HTTP service address (e.g., ':6060')
	-pprof=type: print a pprof-like profile instead
	-d=int: print debug info such as parsed events (1 for high-level, 2 for low-level)

Note that while the various profiles available when launching
'go tool trace' work on every browser, the trace viewer itself

//
// Shell will internally serialize calls to the print function.
// If print is nil, it defaults to printing to stderr.
func NewShell(workDir string, print func(a ...any) (int, error)) *Shell {
	if print == nil {
		print = func(a ...any) (int, error) {
			return fmt.Fprint(os.Stderr, a...)
		}
	}
	shared := &shellShared{
		workDir:   workDir,
		printFunc: print,
	}
	return &Shell{shellShared: shared}
}

                    ${conventions}
                    target.getTasks().register("print${implementationTypeClassName}Configuration", DefaultTask.class, task -> {
                        task.doLast("print restricted extension content", t -> {
                            System.out.println(extension);
                        });
                    });

	"os"
	"regexp"
	"strconv"
	"strings"

	"cmd/internal/objfile"
	"cmd/internal/telemetry"
)

var printCode = flag.Bool("S", false, "print Go code alongside assembly")
var symregexp = flag.String("s", "", "only dump symbols matching this regexp")
var gnuAsm = flag.Bool("gnu", false, "print GNU assembly next to Go assembly (where supported)")
var symRE *regexp.Regexp

func usage() {

            }
        }
    }

    private fun SmartPrinter.printDiagnosticClass(diagnostic: HLDiagnostic, diagnosticList: HLDiagnosticList) {
        print("interface ${diagnostic.className} : KaFirDiagnostic<")
        printTypeWithShortNames(diagnostic.original.psiType)
        print(">")
        inBracketsWithIndent {
            println("override val diagnosticClass get() = ${diagnostic.className}::class")

                    @TaskAction
                    void printValue() {
                        // When ClassLoaders are reused
                        // the 1st run should print `<project name>.value = 1`
                        // the 2nd run should print `<project name>.value = 2`
                        // and so on.
                        System.out.println(projectName + ".value = " + value.incrementAndGet());
                    }