using mlir::PassManager;
using mlir::func::FuncOp;

namespace {

void CreateReplicatedBridgePipelineV1(OpPassManager &pm) {
  pm.addPass(mlir::tf2xla::internal::CreateInferenceMetricsPass());

  // Convert to unified compilation and replication attributes.
  pm.addNestedPass<FuncOp>(
      mlir::TF::CreateCanonicalizeCompileAndReplicateAttributesPass());
  // Guarantee all functions have one use, which enables more exact shape
  // inference.

        """
        when:
        fails("help")
        then:
        failure.assertHasDescription("Execution failed for task ':included:compileJava'.")
        failure.assertHasCause("Compilation failed; see the compiler error output for details.")
    }

    def "buildSrc can apply plugins contributed by a build included by the root build and use them in plugins for the root build"() {

    }

    /**
     * Configures {@code compileTask} to compile against {@code sourceSet}'s compile classpath
     * in addition to the outputs of the java compilation, as specified by {@link SourceSet#getJava()}
     *
     * @param compileTask The task to configure.
     * @param sourceSet The source set whose output contains the java classes to compile against.

            insideVariantDescriptionBlock = isInsideVariantDescriptionBlock(insideVariantDescriptionBlock, line);

            // https://youtrack.jetbrains.com/issue/KT-29546
            if (line.contains("Compilation with Kotlin compile daemon was not successful")) {
                insideKotlinCompilerFlakyStacktrace = true;
                i++;

		if c.Root {
			checkInlCall(fnsym.Name, inlcalls, fnsym.Size, k, -1)
		}
	}

	return inlcalls
}

// Secondary hook for DWARF inlined subroutine generation. This is called
// late in the compilation when it is determined that we need an
// abstract function DIE for an inlined routine imported from a
// previously compiled package.
func AbstractFunc(fn *obj.LSym) {
	ifn := base.Ctxt.DwFixups.GetPrecursorFunc(fn)

      // a control flow operator.
      return errors::Internal(
          "Found cycle in graph without control flow operator during XLA "
          "compilation: ",
          DescribeCycle(cycles, *graph, edge->src()->id(), edge->dst()->id()));
    }
  }

  return true;
}

std::optional<absl::string_view> GetXlaClusterForNode(const Node& node) {

As previously described in this chapter, this is modeled by `A` depending on a _variant of_ `B`, where the variant is selected based on the needs of `A`.
For compilation, we need the API dependencies of `B`, provided by the `apiElements` variant.
For runtime, we need the runtime dependencies of `B`, provided by the `runtimeElements` variant.

        then:
        noExceptionThrown()

        when: "Apache Commons is removed from classpath"
        fails ":${language.compileTaskName}"

        then:
        failure.assertHasCause('Compilation failed; see the compiler error output for details.')
    }

    def "detects changes in compile classpath order"() {
        given:
        // Same class is defined in both project `a` and `b` but with a different ABI

- plugin dependency metadata missing
- plugin dependency metadata retrieval problem
- plugin configuration problem
- plugin execution failure due to something that is know to possibly go wrong (like compilation failure)
- plugin execution error due to something that is not expected to go wrong (the compiler executable missing)
- asking to use a plugin for which you do not have a version defined - tools to easily select versions

		"empty": {
			selector:     "",
			wantFailures: field.ErrorList{field.Required(nil, "")},
		},
		"undefined": {
			selector:     "nosuchvar",
			wantFailures: field.ErrorList{field.Invalid(nil, "nosuchvar", "compilation failed: ERROR: <input>:1:1: undeclared reference to 'nosuchvar' (in container '')\n | nosuchvar\n | ^")},
		},
		"wrong-type": {
			selector:     "1",