registry.insert<shape::ShapeDialect>();
  }

 public:
  StringRef getArgument() const final { return "tf-mhlo"; }
  StringRef getDescription() const final {
    return "This pass will legalize TF Ops to MHLO Ops.";
  }

 protected:
  Option<bool> skip_quantization_ops_{
      *this, "skip-quantization-ops",
      ::llvm::cl::desc("Skip quantization ops")};

  Option<bool> skip_resize_{

// RUN: tf-opt -tfe-legalize-tfg %s | FileCheck %s

module  {
  tfg.graph #tf_type.version<producer = 62, min_consumer = 12> {
    %Const, %ctl = Const name("Constant") {dtype = i32, value = dense<0> : tensor<i32>} : () -> (tensor<i32>)
    %foo, %ctl_0 = foo(%Const) name("_tf.foo") : (tensor<i32>) -> (tensor<*xi32>)
  }
  tfg.func @foo(%arg: tensor<*xi32> {tfg.name = "arg"})
       -> (tensor<*xi32> {tfg.dtype = i32, tfg.name = "return_value"})
   {

// RUN: odml-to-stablehlo-opt %s -tfl-legalize-hlo -split-input-file | FileCheck %s --dump-input=fail

// CHECK-LABEL: mhlo_custom_call_test__legalize_string_backend_config
func.func @mhlo_custom_call_test__legalize_string_backend_config(%arg0: tensor<1x4xf32>) -> tensor<1x8xf32> {
  %0 = mhlo.custom_call @custom_call.my_custom_op(%arg0) {
    api_version = 1 : i32,
    backend_config = "this_is_a_test_string"
  } : (tensor<1x4xf32>) -> (tensor<1x8xf32>)

        }
    }

    static class VisualStudioPluginRootRules extends RuleSource {
        // This ensures that subprojects are realized and register their project and project configuration IDE artifacts
        @Mutate
        public static void ensureSubprojectsAreRealized(TaskContainer tasks, ProjectIdentifier projectIdentifier, ServiceRegistry serviceRegistry) {

        this.componentIdentifier = componentIdentifier;
        this.publishArtifact = publishArtifact;
        // In case the publish artifact is backed by an ArchiveTask, this causes the task to be realized.
        // However, if we are at this point, we need the realized task to determine the archive extension/type later
        // to set the 'artifactType' attribute required in matching (even if the variant with the artifact is not selected in the end).

    def "can execute query and mutation methods #method.key from withType.getByName"() {
        buildFile << """
            testContainer.withType(testContainer.type).getByName("realized") {
                ${method.value}
            }
        """

        expect:
        succeeds "help"

        where:
        method << getQueryMethods() + getMutationMethods()
    }
}

package org.gradle.api.internal.collections;

import javax.annotation.Nullable;

/**
 * Tracks which types are subscribed to by eager event listeners. Lazy elements of a
 * subscribed type should be immediately realized when added to a container.
 */
public interface EventSubscriptionVerifier<T> {

    /**
     * Determines whether events should be emitted for elements of the given type.
     */

          for (auto arg : block.getArguments()) {
            ConvertAndWrapUsesInUnrealizedCast(arg, converter, rewriter);
          }
        }
      }
    });
  });
  return success();
}

// Legalize StableHLO portion of program to VHLO, leaves TFL untouched
LogicalResult ApplyStablehloToVhloPatterns(ModuleOp module,
                                           bool is_func_legal) {
  MLIRContext *context = module.getContext();

            task foo {
                dependsOn tasks.withType(Zip)
                doLast {
                    assert defaultTaskRealizedCount == 0, "All DefaultTask shouldn't be realized"
                    assert zipTaskRealizedCount == 1, "All Zip task should be realized"
                }
            }
        '''

        expect:
        succeeds "foo"
    }

==============================================================================*/

// The TF dialect uses some TF types that are illegal in the MHLO dialect and
// some generic types that are legal in MHLO. This pass legalizes TF types into
// types that are legal in MHLO. For example, TF::Qint8Type is converted to i8.
// Rewrites here should run before TF to MHLO op legalizations are run.

#include <memory>

#include "absl/log/log.h"