/**
     * A comparator implementation based on the names returned by the given namer.
     *
     * @param <T> The type of object that the namer can name
     */
    class Comparator<T> implements java.util.Comparator<T> {

        private final Namer<? super T> namer;

        public Comparator(Namer<? super T> namer) {
            this.namer = namer;
        }

        @Override
        public int compare(T o1, T o2) {

	// does not support names.
	ObjectName(obj runtime.Object) (namespace, name string, err error)
}

type ContextBasedNaming struct {
	Namer         runtime.Namer
	ClusterScoped bool
}

// ContextBasedNaming implements ScopeNamer
var _ ScopeNamer = ContextBasedNaming{}

func (n ContextBasedNaming) Namespace(req *http.Request) (namespace string, err error) {

import _ "testdep_a"

-- syntaxerr/syntaxerr_x_test.go --
package syntaxerr

import _ "testdep_b"

-- nameerr/nameerr.go --
package nameerr

import _ "pkgdep"

-- nameerr/nameerr_i_test.go --
package nameerr

import (
  _ "testdep_a"
  "testing"
)

func TestBad(t *testing.B) {}

-- nameerr/nameerr_x_test.go --
package nameerr_test

import (
  _ "testdep_b"
  "testing"
)

  if (locations.size() < 2 || !isa<NameLoc>(locations.front())) return false;

  StringRef op_type_with_suffix =
      mlir::cast<NameLoc>(locations.front()).getName().strref();
  if (!op_type_with_suffix.ends_with(":")) return false;

  return absl::c_all_of(locations, [](Location loc) {
    return isa<NameLoc>(loc) ||
           (isa<CallSiteLoc>(loc) &&
            isa<NameLoc>(mlir::cast<CallSiteLoc>(loc).getCallee()));
  });

    : CallSiteLoc(CallSiteLoc::get(
          /*callee=*/NameLoc::get(
              StringAttr::get(context, ConcatNodeAndFuncName(unit.node_name(),
                                                             unit.func_name())),
              /*childLoc=*/NameLoc::get(
                  StringAttr::get(context, unit.op_type()))),
          /*caller=*/NameLoc::get(StringAttr::get(

          auto new_call = mutable_location->mutable_call()->Add();
          ExtractFileLine(loc, new_call->mutable_source());
        })
        .Case<NameLoc>([&](NameLoc loc) {
          if (!mutable_location->has_type()) {
            mutable_location->set_type(ConverterErrorData::NAMELOC);
          }

          auto new_call = mutable_location->mutable_call()->Add();
          new_call->set_name(loc.getName().str());

        private final String name;
        private final org.gradle.api.Namer<? super T> namer;

        public HasNamePredicate(String name, org.gradle.api.Namer<? super T> namer) {
            this.name = name;
            this.namer = namer;
        }

        @Override
        public boolean apply(@Nullable T input) {
            return namer.determineName(input).equals(name);
        }
    }

    private final MutationGuard parentMutationGuard;

    public DefaultNamedDomainObjectSet(Class<? extends T> type, Instantiator instantiator, Namer<? super T> namer, CollectionCallbackActionDecorator decorator) {
        super(type, new SortedSetElementSource<T>(new Namer.Comparator<T>(namer)), instantiator, namer, decorator);
        this.parentMutationGuard = MutationGuards.identity();
    }

        "test" | "compile" | "java"      | "compileTestJava"
    }

    def "generates binary name and output directory"() {
        def namer = new ClassDirectoryBinaryNamingScheme(baseName)

        expect:
        namer.binaryName == binaryName
        namer.outputDirectoryBase == outputDir

        where:
        baseName | binaryName | outputDir
        "main"   | "main"     | "main"

// op. The `ConstOp` will be created at `builder`'s current insertion point.
TF::ConstOp CreateTensorNamesConst(const ArrayRef<std::string> tensor_names,
                                   OpBuilder& builder) {
  const auto loc = NameLoc::get(builder.getStringAttr("tensor_names"));
  return Create1DStringConst(tensor_names, loc, builder);
}

// Creates a 1D string array constant for "shape_and_slices" input of