E.g. `--stacktrace` for a compilation error is not helpful.

To influence the generic suggestions Gradle displays, the NonGradleCause interface was introduced.
If an exception implements this interface, Gradle will not display the `--stacktrace` option.

Another more targeted interface is `CompilationFailedIndicator`.
This interface is used to indicate that the exception is caused by a compilation failure. 

	cu           *Entry // current compilation unit
}

// Reader returns a new Reader for [Data].
// The reader is positioned at byte offset 0 in the DWARF “info” section.
func (d *Data) Reader() *Reader {
	r := &Reader{d: d}
	r.Seek(0)
	return r
}

// AddressSize returns the size in bytes of addresses in the current compilation
// unit.
func (r *Reader) AddressSize() int {

    bool allow_string_consts = true;

    // Whether to allow the compilation of CollectiveReduceV2Op.
    bool allow_collective_reduce_v2 = true;

    // Whether to allow the compilation of WhereOp.
    bool allow_where_op = true;

    // Whether to allow the compilation of UniqueOp. Compilation of the UniqueOp
    // generates output with bounded dynamic shape that may cause failures with

                """#if swift(>=4.0)
                        XCTFail("Compilation unit compiled with Swift 4+ instead of Swift 3.x");
                    #elseif swift(>=3.0)
                        // Do nothing
                    #else
                        XCTFail("Compilation unit compiled with Swift 2- instead of Swift 3.x");
                    #endif
                """)
        ]
    }

};

TEST_F(ExtractOutsideCompilationForFunctionTest, Basic) {
  // Build the XLA computation func.
  // "const0"
  // "identity0" = "const0" (outside compilation cluster "0")
  // "identity1" = "identity0" (outside compilation cluster "1")
  // "identity2" = "identity1"
  FunctionDefLibrary fdl;
  {
    tensorflow::Scope s = tensorflow::Scope::NewRootScope();

        when:
        succeeds ':compileJava' // the internal class can be accessed

        then:
        javaClassFile('consumer/MainModule.class').exists()
    }

    def "fails module compilation for missing requires"() {
        given:
        producingModuleInfo('exports producer')
        producingModuleClass()
        consumingModuleInfo()
        consumingModuleClass('producer.ProducerClass')

import org.gradle.test.preconditions.UnitTestPreconditions

class JreJavaHomeJavaIntegrationTest extends AbstractIntegrationSpec {

    @Requires(IntegTestPreconditions.BestJreAvailable)
    def "java compilation works in forking mode = #forkMode when JAVA_HOME is set to JRE"() {
        given:
        def jreJavaHome = AvailableJavaHomes.bestJre
        writeJavaTestSource("src/main/java");
        file('build.gradle') << """

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.util.Collection;
import java.util.Objects;

/**
 * A compiler that selects classes for compilation. It also handles restore of output state in case of a compile failure.
 */
class SelectiveCompiler<T extends JavaCompileSpec> implements org.gradle.language.base.internal.compile.Compiler<T> {

 * - Source sets should be able to depend on other source sets, resulting in the correct task dependencies and inputs
 * - Joint-compilation should only be used in the case where sources are co-dependent.
 *
 * Currently we use joint-compilation when:
 * - We have a language transform that supports joint-compilation
 * - Binary is flagged with {@link BinarySpecInternal#hasCodependentSources()}.
 */
public class BinarySourceTransformations {

rootProject.name = "cross-compilation"...