private
    fun newConstructorForSerialization(beanType: Class<*>, constructor: Constructor<*>): Constructor<out Any> =
        ReflectionFactory.getReflectionFactory().newConstructorForSerialization(beanType, constructor)

      legalization.
  }];
  let constructor = "CreateAnalyzeVariablesPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
}

def DefaultQuantParamsPass : Pass<"tfl-default-quant", "mlir::func::FuncOp"> {
  let summary = "Apply quantization with default quantization parameter";
  let constructor = "CreateDefaultQuantParamsPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];

            Constructor<? extends T> constructor = generatedClass.getConstructor(GeneratedViewState.class, TypeConverter.class);
            return constructor.newInstance(state, null);
        } catch (InvocationTargetException e) {
            throw UncheckedException.throwAsUncheckedException(e.getTargetException());

    }

    /**
     * The actual constructor called by concrete resolve exception implementations. Should not be
     * called except from Gradle internal code.
     *
     * <p>This constructor accepts a dummy parameter since we cannot call the constructor without it,
     * as that emits a deprecation warning. In 9.0, we can change the above constructor to protected
     * and remove this constructor.</p>
     *
     * @since 8.9
     */

    }

    public static class CachedConstructor {
        private final ClassGenerator.GeneratedConstructor<?> constructor;
        private final RuntimeException error;

        private CachedConstructor(ClassGenerator.GeneratedConstructor<?> constructor, RuntimeException error) {
            this.constructor = constructor;
            this.error = error;
        }

        public ClassGenerator.GeneratedConstructor<?> getConstructor() {

/**
 * State might be corrupted and should be discarded.
 */
@Contextual
class ConfigurationCacheError internal constructor(
    error: String,
    cause: Throwable? = null
) : ConfigurationCacheThrowable, Exception(error, cause)


@Contextual
sealed class ConfigurationCacheException protected constructor(
    message: () -> String,
    causes: Iterable<Throwable>

     * The returned {@link Instantiator} is lenient when there is a missing {@link javax.inject.Inject} annotation or null constructor parameters,
     * for backwards compatibility.
     *
     * <p>Use for any model types for which no user provided constructor values or services need to be injected. This is a convenience for {@link #decorateLenientScheme()} and will also be retired.
     */

    MLIR pipeline in the future.
  }];
  let constructor = "TF::CreateGpuOpFusionPass()";
}

def BatchMatMulToEinsumPass : Pass<"tf-batch-matmul-to-tf-einsum", "mlir::func::FuncOp"> {
  let summary = "Replace TF BatchMatMul op by TF Einsum op.";
  let constructor = "TF::CreateBatchMatMulToEinsumPass()";
}

        factories.add(factory);
      }
    }
    if (!Modifier.isAbstract(type.getRawType().getModifiers())) {
      for (Constructor<?> constructor : type.getRawType().getDeclaredConstructors()) {
        Invokable<T, T> invokable = type.constructor(constructor);
        if (!invokable.isPrivate() && !invokable.isSynthetic()) {
          factories.add(invokable);
        }
      }
    }

     *
     * @param serviceType The service implementation to make visible.
     */
    void add(Class<?> serviceType);

    /**
     * Adds a service to this registry. The implementation class should have a single public constructor, and this constructor can take services to be injected as parameters.
     *