context->appendDialectRegistry(registry_);
  context->loadAllAvailableDialects();

  // Run TAC passes.
  auto status = RunTacPasses(&module, options_.debug_mode);

  if (!status.ok()) {
    return status;
  }

  return exporter_->Export(module);
}

void TacModule::RegisterExtraDialects(mlir::DialectRegistry& registry) {
  registry.appendTo(registry_);
}
}  // namespace tac

namespace tensorflow {
namespace gradients {
TapeOperation::TapeOperation(AbstractOperation* parent_op, Tape* tape,
                             const GradientRegistry& registry)
    : AbstractOperation(kTape),
      parent_op_(parent_op),
      tape_(tape),
      registry_(registry) {
  // TODO(b/172003047): Consider making AbstractOperation RefCounted.
  // parent_op_->Ref();
}
void TapeOperation::Release() {

  const std::vector<const tac::TargetHardware*>& GetAvailableHardwares() const {
    return const_backends_;
  }

  // Registers all dialects in 'registry' with the module.
  // This to allow clients to register extra dialects required.
  void RegisterExtraDialects(mlir::DialectRegistry& registry);

 protected:
  // Adds TAC passes to the 'pass_manager'.
  virtual void AddTACPass(mlir::OpPassManager* pass_manager,

//   // More complex gradient functions can use inputs/attrs etc. from the
//   // forward `op`.
//   return new AddGradientFunction;
// }
//
// Status RegisterGradients(GradientRegistry* registry) {
//   return registry->Register("Add", AddRegisterer);
// }
class GradientFunction {
 public:
  virtual Status Compute(AbstractContext* ctx,
                         absl::Span<AbstractTensorHandle* const> grad_outputs,

        registry.versions.size() == 1
        registry.libraries.size() == 1
        registry.versions[0].alias == "group-artifact"
        registry.versions[0].module == "group:artifact"
        registry.versions[0].version == "1.1"
        registry.libraries[0].alias == "group-artifact"
        registry.libraries[0].module == "group:artifact"
        registry.libraries[0].version == "1.1"
        registry.libraries[0].versionRef == "group-artifact"

    def "can add type to registry that has package private constructor"() {
        when:
        def registry = new DefaultServiceRegistry()
        registry.register {
            it.add(String, "Potato")
            it.add(ModifierStubs.PackagePrivateConstructor)
        }
        then:
        noExceptionThrown()

    }

    def "cannot register a handle once the registry is stopped" () {
        given:
        registry.stop()

        when:
        registry.start("id", DeploymentRegistry.ChangeBehavior.NONE, TestDeploymentHandle)
        then:
        def e = thrown(IllegalStateException)
        e.message == "Cannot modify deployment handles once the registry has been stopped."
    }

    def registry = Mock(WindowsRegistry)

    def "no detection for non-windows os"() {
        given:
        def supplier = createSupplier(OperatingSystem.MAC_OS)

        when:
        supplier.get()

        then:
        0 * registry._
    }

    def "finds openjdk homes"() {
        given:

        })

        expect:
        10.times {
            start {
                assert registry.get(String) == "12"
                assert registry.get(Long) == 123
            }
        }
    }

    def "multiple threads can locate factories"() {
        def registry = new DefaultServiceRegistry()
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides

        registry.registerOutputs(file('build/outputs'))
        registry.registerOutputs(file('build/outputs/other'))
        registry.registerOutputs(file('outputs'))
        registry.resolveOutputs()

        expect:
        registry.isOutputOwnedByBuild(file('build/outputs'))
        registry.isOutputOwnedByBuild(file('build/outputs/some-dir/other-dir'))
        registry.isOutputOwnedByBuild(file('build/outputs/other'))