jvmArgs(listOf("--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"))

        if (isUnitTest() || usesEmbeddedExecuter()) {
            jvmArgs(org.gradle.internal.jvm.JpmsConfiguration.GRADLE_DAEMON_JPMS_ARGS)
        } else {

// compile

// Copyright 2013 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.

// Test multiple identical unnamed structs with methods.  This caused
// a compilation error with gccgo.

package p

type S1 struct{}

func (s S1) M() {}

type S2 struct {
	F1 struct {
		S1
	}
	F2 struct {
		S1
	}
}

type I interface {

	a, b, c, d = a0, b0, c0, d0
	defer func() { recover() }()
	panic("XXX")
	return
}

func main() {
	a1, b1, zero, c1, d1 := F()
	if a1 != a0 || b1 != b0 || c1 != c0 || d1 != d0 || zero != 0 { // unnamed result gets zero value
		panic("FAIL")
	}

            // For java.util.concurrent.CountDownLatch being serialized reflectively by configuration cache
            executer.withArgument('-Dorg.gradle.jvmargs=--add-opens java.base/java.util.concurrent=ALL-UNNAMED --add-opens java.base/java.util.concurrent.locks=ALL-UNNAMED')
        }

        buildFile << """
            import org.gradle.internal.operations.BuildOperationExecutor
            import org.gradle.internal.operations.RunnableBuildOperation

// generated equality functions on architectures that can't do
// unaligned loads.

package main

// T has a big field that wants to be compared with larger loads/stores.
// T is "special" because of the unnamed field, so it needs a generated equality function.
// T is an odd number of bytes in size and has alignment 1.
type T struct {
	src [8]byte
	_   byte
}

// U contains 8 copies of T, each at a different %8 alignment.

    override fun asArguments() : Iterable<String> {
        return if (test.javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)) {
            listOf("--add-opens=java.base/java.lang=ALL-UNNAMED")
        } else {
            emptyList()
        }
    }
}
tasks.withType<Test>().configureEach {
    jvmArgumentProviders.add(AddOpensArgProvider(this))

        this.test = test;
    }
    @Override
    Iterable<String> asArguments() {
        return test.javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)
            ? ["--add-opens=java.base/java.lang=ALL-UNNAMED"]
            : []
    }
}
tasks.withType(Test).configureEach {
    jvmArgumentProviders.add(new AddOpensArgProvider(it))

            javaForkOptions.jvmArgs(
                "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
                "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
            );
        } else {
            // In JDK 8 and below, the compiler internal classes are in tools.jar.
            File toolsJar = jvm.getToolsJar();

# library contains "foo1", "foo2", ..., "foo20", from which "foo1" and "foo11"
# were mapped to the same name "foo110" in the bug.
node {
  name: "unnamed"
  op: "foo1"
}
node {
  name: "unnamed1"
  op: "foo11"
}
library {
  function {
    signature {
      name: "foo1"
    }
  }
  function {
    signature {
      name: "foo2"
    }
  }
  function {

		case TINT32:
			return (t1 == Types[TINT32] || t1 == RuneType) && (t2 == Types[TINT32] || t2 == RuneType)
		case TINTER:
			// Make sure named any type matches any unnamed empty interface
			// (but not a shape type, if identStrict).
			isUnnamedEface := func(t *Type) bool { return t.IsEmptyInterface() && t.Sym() == nil }
			if flags&identStrict != 0 {