ruleAction.execute("string", [])

        then:
        ruleAction.inputTypes == []
        closureCalled == "string"

        when:
        ruleAction = ruleActionAdapter.createFromClosure(String, { s -> closureCalled = s })
        ruleAction.execute("object", [])

        then:
        ruleAction.inputTypes == []
        closureCalled == "object"

        when:

    private final List<Class<?>> inputTypes;

    public ClosureBackedRuleAction(Class<T> subjectType, Closure<?> closure) {
        this.subjectType = subjectType;
        this.closure = closure;
        this.inputTypes = parseInputTypes(closure);
    }

    @Override
    public List<Class<?>> getInputTypes() {
        return inputTypes;
    }

    @Override

        File input = getInput().get().getAsFile();
        InstrumentationInputType inputType = getInputType(input);
        switch (inputType) {
            case DEPENDENCY_ANALYSIS_DATA:
                doMergeAndOutputAnalysis(input, outputs);
                return;
            case ORIGINAL_ARTIFACT:

  for (auto input : llvm::zip(getOperandTypes(), getInputSpecs())) {
    Type inputType = std::get<0>(input);
    Attribute inputSpec = std::get<1>(input);
    if (!isValidQuantizationSpec(inputSpec, inputType)) {
      return emitOpError() << "has incompatible specification " << inputSpec
                           << " and input type " << inputType;
    }
  }

  for (auto result : llvm::zip(getResultTypes(), getOutputSpecs())) {

  for (auto input : llvm::zip(getOperandTypes(), getInputSpecs())) {
    Type inputType = std::get<0>(input);
    Attribute inputSpec = std::get<1>(input);
    if (!isValidQuantizationSpec(inputSpec, inputType)) {
      return emitOpError() << "has incompatible specification " << inputSpec
                           << " and input type " << inputType;
    }
  }

  for (auto result : llvm::zip(getResultTypes(), getOutputSpecs())) {

  }

  std::vector<Value> inputs;
  std::vector<Value> outputs;
  computeInputsOutputs(ops, &inputs, &outputs);

  std::vector<Type> input_types;
  std::vector<Type> output_types;

  input_types.reserve(inputs.size());
  for (Value v : inputs) {
    input_types.push_back(v.getType());
  }
  output_types.reserve(outputs.size());
  for (Value v : outputs) {
    output_types.push_back(v.getType());
  }

absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>>
GraphdefToMlirTranslateFunction(
    llvm::StringRef input, const std::vector<std::string>& input_arrays,
    const std::vector<std::string>& input_dtypes,
    const std::vector<std::optional<std::vector<int>>>& input_shapes,
    const std::vector<std::string>& output_arrays,
    const std::vector<std::string>& control_output_arrays,

    private final R instance;
    private final JavaMethod<R, T> ruleMethod;
    private final List<Class<?>> inputTypes;

    private RuleSourceBackedRuleAction(R instance, JavaMethod<R, T> ruleMethod) {
        this.instance = instance;
        this.ruleMethod = ruleMethod;
        this.inputTypes = determineInputTypes(ruleMethod.getParameterTypes());
    }

}

Type InferReductionOpType(Value input, Value reduction_indices,
                          BoolAttr keep_dims) {
  Type input_ty = input.getType();
  Type element_ty = getElementTypeOrSelf(input_ty);

  // Output type is unranked if input type is not ranked.
  auto ranked_ty = mlir::dyn_cast<RankedTensorType>(input_ty);
  if (!ranked_ty) return UnrankedTensorType::get(element_ty);
  int64_t rank = ranked_ty.getRank();

    static {
        Map<Type, String> map = new HashMap<>();
        map.put(Type.BYTE_TYPE, "0");
        map.put(Type.SHORT_TYPE, "0");
        map.put(Type.INT_TYPE, "0");
        map.put(Type.LONG_TYPE, "0L");
        map.put(Type.FLOAT_TYPE, "0.0f");
        map.put(Type.DOUBLE_TYPE, "0.0");
        map.put(Type.CHAR_TYPE, "'\\u0000'");
        map.put(Type.BOOLEAN_TYPE, "false");