import static org.gradle.sample.utilities.StringUtils.join;
import static org.gradle.sample.utilities.StringUtils.split;
import static org.gradle.sample.app.MessageUtils.getMessage;

public class Main {
    public static void main(String[] args) {
        LinkedList tokens;
        tokens = split(getMessage());
        System.out.println(join(tokens));
    }

package org.sample.myapp;

import org.sample.numberutils.Numbers;

public class Main {

    public static void main(String... args) {
        new Main().printAnswer();
    }

    public void printAnswer() {
        String output = " The answer is " + Numbers.add(19, 23);
        System.out.println(output);
    }

package org.sample.myapp;

import org.sample.numberutils.Numbers;

public class Main {

    public static void main(String... args) {
        new Main().printAnswer();
    }

    public void printAnswer() {
        String output = " The answer is " + Numbers.add(19, 23);
        System.out.println(output);
    }

// from the plugin jumps in the middle of the function
// to the function with the same name in the main
// executable. As these two functions may be compiled
// differently as plugin needs to be PIC, this causes
// crash.

package main

import (
	"plugin"

	"testplugin/issue53989/p"
)

func main() {
	p.Square(7) // call the function in main executable

	p, err := plugin.Open("issue53989.so")
	if err != nil {
		panic(err)

//go:build ignore

package main

// // No C code required.
import "C"

func FuncInt() int { return 1 }

// Add a recursive type to check that type equality across plugins doesn't
// crash. See https://golang.org/issues/19258
func FuncRecursive() X { return X{} }

type Y struct {
	X *X
}
type X struct {
	Y Y
}

import org.gradle.launcher.cli.DefaultCommandLineActionFactory;

import java.util.Arrays;

/**
 * The main command-line entry-point for Gradle.
 */
public class Main extends EntryPoint {
    public static void main(String[] args) {
        new Main().run(args);
    }

    @Override
    protected void doAction(String[] args, ExecutionListener listener) {

// Copyright 2022 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 main

import "test/a"

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

// A type can be passed to a plugin and converted to interface
// there. So its methods need to be live.

package main

import (
	"plugin"

	"testplugin/method2/p"
)

var t p.T

type I interface{ M() }

func main() {
	pl, err := plugin.Open("method2.so")
	if err != nil {
		panic(err)
	}

	f, err := pl.Lookup("F")
	if err != nil {
		panic(err)
	}

// An unexported method can be reachable from the plugin via interface
// when a package is shared. So it need to be live.

package main

import (
	"plugin"

	"testplugin/method3/p"
)

var i p.I

func main() {
	pl, err := plugin.Open("method3.so")
	if err != nil {
		panic(err)
	}

	f, err := pl.Lookup("F")
	if err != nil {
		panic(err)
	}

// Copyright 2020 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 main

import (
	"bytes"
	"fmt"
	"os"
	"os/exec"
)

func main() {
	if len(os.Args) > 1 {
		// Generate a SIGILL.
		sigill()
		return
	}
	// Run ourselves with an extra argument. That process should SIGILL.