include "mlir/Pass/PassBase.td"

def EmbeddingPipeliningPass : Pass<"tf-embedding-pipelining", "mlir::ModuleOp"> {
  let summary = "Rewrite graph for embedding pipelining";
  let constructor = "TFDevice::CreateEmbeddingPipeliningPass()";
    let description = [{
    For architectures that support accelerated embedding lookups, this pass will
    rewrite the graph to use pipelining for better device utilization.

  /// TaggedValue constructor for type FLOAT32.
  explicit TaggedValue(float f32) : type_(FLOAT32), data_(Float32(f32)) {}
  /// TaggedValue constructor for type INT64.
  explicit TaggedValue(int64_t i64) : type_(INT64), data_(Int64(i64)) {}
  /// TaggedValue constructor for type FLOAT32.
  explicit TaggedValue(Float32 f32) : type_(FLOAT32), data_(f32) {}
  /// TaggedValue constructor for type INT64.

      return arbitraryConstantInstanceOrNull(type);
    }
    final Constructor<T> constructor;
    try {
      constructor = type.getConstructor();
    } catch (NoSuchMethodException e) {
      return arbitraryConstantInstanceOrNull(type);
    }
    constructor.setAccessible(true); // accessibility check is too slow
    try {
      return constructor.newInstance();

    include verifying that clusters have been created and have been outside
    compiled, the result is device agnostic and in TF functional dialect &
    that the device attribute exists.
  }];

  let constructor = "tensorflow::tf2xla::internal::CreateVerifyClusteringPass()";
}

def TPUClusterFormationPass : Pass<"tf-tpu-cluster-formation", "ModuleOp"> {

    CLASS CLASS name:Child modality:FINAL visibility:public superTypes:[p2.Parent]
      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Child
      CONSTRUCTOR visibility:public <> () returnType:<root>.Child [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () declared in p2.Parent'
          INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Child modality:FINAL visibility:public superTypes:[p2.Parent]'

import org.codehaus.groovy.runtime.callsite.CallSite;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.util.Set;

/**
 * Intercepts method and constructor calls as well as property reads in dynamic Groovy bytecode.
 * <p>
 * The interceptor serves as a factory for decorated Groovy {@link CallSite} instances.

 * It only intercepts the calls where the receiver is the class of interest.
 * <p>
 * It is possible but not strictly necessary to use this interceptor to intercept constructors.
 * Due to the way constructor interception works, having an {@link InterceptScope#constructorsOf(Class)
 * as a scope already guarantees that the invocation would have the given class object as the receiver.
 */

    Constructor<ArrayList> constructor = ArrayList.class.getConstructor();
    assertEquals(
        TypeToken.of(ArrayList.class),
        TypeToken.of(ArrayList.class).constructor(constructor).getOwnerType());
    assertEquals(
        new TypeToken<ArrayList<String>>() {},
        new TypeToken<ArrayList<String>>() {}.constructor(constructor).getOwnerType());
  }

      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CodeFragment
      CONSTRUCTOR visibility:public <> () returnType:<root>.CodeFragment [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
      FUN name:run visibility:public modality:FINAL <> (p0:kotlin.Int, p1:kotlin.String) returnType:kotlin.Unit

import org.gradle.internal.service.ServiceRegistration
import org.gradle.internal.service.ServiceRegistry
import org.slf4j.LoggerFactory
import spock.lang.Specification

import javax.inject.Inject
import java.lang.reflect.Constructor

class NativeServicesInitializationTest extends Specification {

    def "cannot get an instance of NativeServices without initializing first" () {