// Attribute indicating that this is an IdentityN node receiving inputs for a
// outside compilation Placeholder node (the original outside compilation node
// is moved out of TPU computation, and we left a Placeholder node there).
// Attribute value will be a string, which is the outside compilation cluster
// name for the outside compilation Placeholder node.
extern const char kXlaOutsideCompilationInputsAttrName[];

// either unsafe.Sizeof and Alignof, nor runtime, reflect, or reflectlite.

// CommonSize returns sizeof(Type) for a compilation target with a given ptrSize
func CommonSize(ptrSize int) int { return 4*ptrSize + 8 + 8 }

// StructFieldSize returns sizeof(StructField) for a compilation target with a given ptrSize
func StructFieldSize(ptrSize int) int { return 3 * ptrSize }

            }
        """
    }

    def "when doing a join compilation java problems are formatted the same as a standalone compication"() {
        given:
        file("src/main/groovy/JavaThing.java") << """\
            public class JavaThing {
                public void badMethod() {
                    // The following line will cause a compilation error
                    return "Hello, World!"
                }

        private final ProblemGroup java = new DefaultProblemGroup("java", "Java compilation", this);
        private final ProblemGroup groovy = new DefaultProblemGroup("groovy", "Groovy compilation", this);
        public ProblemGroup groovyDsl = new DefaultProblemGroup("groovy-dsl", "Groovy DSL script compilation", this);

        private DefaultCompilationProblemGroup(String id, String displayName) {

import java.io.File

/**
 * In-memory compilation result returned from [KaCompilerFacility].
 *
 * Compilation fails if there are critical errors reported either on the frontend or on the backend side.
 * Keep in mind that [KaCompilationResult] is a part of Analysis API, so it should only be used inside an analysis block.
 */
public sealed class KaCompilationResult {
    /**
     * Successful compilation result.
     *

        'compilation:java:initialization-failed' : 'Java compilation initialization error',
        'compilation:java:java-compilation-error' : 'Java compilation error',
        'compilation:java:java-compilation-failed' : 'Java compilation error',
        'compilation:java:java-compilation-warning' : 'Java compilation warning',

	c := &Controller{}
	if filter != nil {
		compilation := cel.Compiler.CompileCELExpression(filter.Selector, environment.StoredExpressions)
		if compilation.Error != nil {
			// Shouldn't happen because of validation.
			return nil, fmt.Errorf("compile class filter CEL expression: %w", compilation.Error)
		}
		c.filter = &compilation
	}
	for _, request := range requests {

                ) {
                }
            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:
        assertThat(compilation).succeededWithoutWarnings()
        assertThat(compilation)
            .generatedFile(CLASS_OUTPUT, "META-INF/services/org.gradle.internal.classpath.intercept.FilterableCallInterceptor")

            << " because it is megamorphic.";
    return false;
  }

  // TODO(b/255826209): Figure out if Lazy compilation is still needed given
  // that we always compile a cluster the first time it is executed (explained
  // below) regardless of compilation mode. If it is not, clean up the related
  // logic.
  // We always compile a cluster the very first time it is executed.  This is an

#include <memory>
#include <string>

#include "tensorflow/compiler/tf2xla/xla_argument.h"
#include "tensorflow/core/graph/graph.h"

namespace tensorflow {
// The number of compiler threads to use for asynchronous device compilation.
inline constexpr int64_t kNumAsyncDeviceCompilerThreads = 10;

enum class DeviceCompileMode {
  kLazy,
  kStrict,
  kAsync,
};

enum class DeviceCompileState {
  kUncompiled,
  kCompiling,