compilerArgs.add '-W3'

    // Define toolchain-specific compiler options
    compilerArgs.addAll toolChain.map { toolChain ->
        if (toolChain in [ Gcc, Clang ]) {
            return ['-O2', '-fno-access-control']
        } else if (toolChain in VisualCpp) {
            return ['/Zi']
        }
        return []
    }
}
// end::cpp-compiler-options-all-variants[]

        Object o1 = new Object();
        scope.seed(Object.class, o1);
        assertSame(o1, scope.scope(Key.get(Object.class), null).get());

        scope.enter();
        Object o2 = new Object();
        scope.seed(Object.class, o2);
        assertSame(o2, scope.scope(Key.get(Object.class), null).get());

        scope.exit();
        assertSame(o1, scope.scope(Key.get(Object.class), null).get());

        scope.exit();

    compilerArgs.add("-W3")

    // Define toolchain-specific compiler options
    compilerArgs.addAll(toolChain.map { toolChain ->
        when (toolChain) {
            is Gcc, is Clang -> listOf("-O2", "-fno-access-control")
            is VisualCpp -> listOf("/Zi")
            else -> listOf()
        }
    })
}
// end::cpp-compiler-options-all-variants[]

// tag::cpp-compiler-options-per-variants[]

  static int unsafeCompare(
      @CheckForNull Comparator<?> comparator, @CheckForNull Object o1, @CheckForNull Object o2) {
    if (comparator == null) {
      return ((Comparable<@Nullable Object>) o1).compareTo(o2);
    } else {
      return ((Comparator<@Nullable Object>) comparator).compare(o1, o2);
    }
  }

  /**
   * A sensible definition of {@link #containsKey} in terms of the {@code firstKey()} method of

        }
        final Ingester[] newIngesters = Arrays.copyOf(ingesters, ingesters.length + 1);
        newIngesters[ingesters.length] = ingester;
        Arrays.sort(newIngesters, (o1, o2) -> o1.priority - o2.priority);
        ingesters = newIngesters;
    }

    public Ingester[] getIngesters() {
        return ingesters;
    }

    public JvmInstallationMetadataComparator(File currentJavaHome) {
        this.currentJavaHome = currentJavaHome;
    }

    @Override
    public int compare(JvmInstallationMetadata o1, JvmInstallationMetadata o2) {
        return Comparator
            .comparing(this::isCurrentJvm)
            .thenComparing(this::isJdk)
            .thenComparing(this::extractVendor, Comparator.reverseOrder())

                    interceptor.ruleFields.sort(new Comparator<FieldInfo>() {
                        @Override
                        int compare(FieldInfo o1, FieldInfo o2) {
                            def o1Class = o1.reflection.declaringClass
                            def o2Class = o2.reflection.declaringClass
                            if (o1Class != o2Class) {
                                if (o1Class.isAssignableFrom(o2Class)) {

 */
@NonNullApi
class TaskDetails {
    final static Comparator<TaskDetails> DEFAULT_COMPARATOR = (o1, o2) -> {
        // tasks in higher-up projects first
        int depthCompare = o1.getProjectDepth() - o2.getProjectDepth();
        if (depthCompare != 0) {
            return depthCompare;
        }
        return o1.getPath().compareTo(o2.getPath());
    };

    /**

        def args = transformer.transform(spec)
        args.containsAll(expected)

        where:
        debug | optimize | expected
        true  | false    | ["/Zi"]
        false | true     | ["/O2"]
        true  | true     | ["/Zi", "/O2"]
    }

    def "transforms system header and include args correctly"() {
        def spec = Stub(NativeCompileSpec)
        def includes = [ new File("/foo"), new File("/bar") ]

def _composite_no_op():
  pass


@Composite(
    'TestCompositeOp',
    inputs=['x: T', 'y: T'],
    attrs=['act: {"", "relu"}', 'trans: bool = true'],
    derived_attrs=['T: numbertype'],
    outputs=['o1: T', 'o2: T'])
def _composite_op(x, y, act, trans):
  return x + act, y + trans


class TFRGenTensorTest(test.TestCase):
  """MLIR Generation Tests for MLIR TFR Program."""

  def test_op_reg_gen(self):