import p3.foo

@MyComposable
fun Greeting(): String {
    return "Hi $foo!"
}

// FILE: p3/foo.kt
package p3

import org.jetbrains.kotlin.fir.plugin.MyComposable

private var foo_ = 0

fun setFoo(newFoo: Int) {
    foo_ = newFoo
}

val foo: Int

	g := Gcd(x, y)
	fmt.Println("The gcd of", x, "and", y, "is", g)

	// Manipulate the Foo global variable

	// Output its current value
	fmt.Println("Foo =", GetFoo())

	// Change its value
	SetFoo(3.1415926)

	// See if the change took effect
	fmt.Println("Foo =", GetFoo())
}
-- main.swig --
%module main

%inline %{
extern int    gcd(int x, int y);
extern double Foo;
%}
-- main_test.go --
package main

 * limitations under the License.
 */

package org.gradle.workers.fixtures;

import org.gradle.api.Named;

public class TestManagedTypes {
    public interface ManagedThing {
        String getFoo();
        void setFoo(String foo);
    }

    public interface ImmutableManagedThing extends Named {
    }

                @Inject abstract ProviderFactory getProviderFactory()

                @Internal abstract Property<String> getOther()

                @Internal Provider<String> getFoo() {
                    return other;
                }

                @TaskAction
                void useIt() {
                    assert foo.get() == "foobar"
                }
            }

 func (t <esc:0x12> <type 12>) Location () <type 14>;
 func (t <esc:0x32> <type 12>) Zone () (name <type -16>, offset <type -11>);
 func (t <esc:0x12> <type 12>) Local () <type 12>;
 func (t <esc:0x1> <type 28>) .time.setLoc (loc <type 14>);
 func (t <esc:0x12> <type 12>) Truncate (d <type 26>) <type 12>;
 func (t <esc:0x1> <type 12>) MarshalJSON () (? <type 30 [] <type -20>>, ? <type -19>);

        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal abstract ConfigurableFileCollection getFoo()
                @Internal abstract ConfigurableFileCollection getBar()
                @Inject abstract ProjectLayout getLayout()

                @TaskAction
                void useIt() {

	}
}

func TestMonotonicSub(t *testing.T) {
	t1 := Unix(1483228799, 995e6)
	SetMono(&t1, 123456789012345)

	t2 := Unix(1483228799, 5e6)
	SetMono(&t2, 123456789012345+10e6)

	t3 := Unix(1483228799, 995e6)
	SetMono(&t3, 123456789012345+1e9)

	t1w := t1.AddDate(0, 0, 0)
	if GetMono(&t1w) != 0 {
		t.Fatalf("AddDate didn't strip monotonic clock reading")

 * It features an <code>execute()</code> method, which triggers the Mojo's build-process behavior, and can throw
 * a MojoExecutionException or MojoFailureException if error conditions occur.<br>
 * Also included is the <code>setLog(...)</code> method, which simply allows Maven to inject a logging mechanism which
 * will allow the Mojo to communicate to the outside world through standard Maven channels.
 *
 */
public interface Mojo {

	zoneinfo = nil
	zoneinfoOnce = sync.Once{}
}

var (
	DisablePlatformSources = disablePlatformSources
	GorootZoneSource       = gorootZoneSource
	ParseTimeZone          = parseTimeZone
	SetMono                = (*Time).setMono
	GetMono                = (*Time).mono
	ErrLocation            = errLocation
	ReadFile               = readFile
	LoadTzinfo             = loadTzinfo
	NextStdChunk           = nextStdChunk

        MavenProject project = session.getCurrentProject();
        if (project != null) {
            setRepositories(project.getRemotePluginRepositories());
            setPom(project.getModel());
        }

        setPluginGroups(session.getPluginGroups());
    }

    public String getPrefix() {
        return prefix;
    }