private boolean isMatch(Class<?>[] argumentTypes, Class<?>[] parameterTypes) {
            for (int i = 0; i < argumentTypes.length; i++) {
                Class<?> argumentType = argumentTypes[i];
                Class<?> parameterType = parameterTypes[i];
                boolean primitive = parameterType.isPrimitive();
                if (primitive) {
                    if (argumentType == null) {
                        return false;

        methodDesc.append(getName());
        methodDesc.append("(");
        Type[] argumentTypes = Type.getArgumentTypes(getTypeDesc());
        for (int i = 0, argumentTypesLength = argumentTypes.length; i < argumentTypesLength; i++) {
            Type type = argumentTypes[i];
            methodDesc.append(type.getClassName());
            if (i < argumentTypesLength - 1) {

        return options;
    }

    public CommandLineOption hasArgument(Class<?> argumentType) {
        this.argumentType = argumentType;
        return this;
    }

    public CommandLineOption hasArgument() {
        this.argumentType = String.class;
        return this;
    }

    public CommandLineOption hasArguments() {
        argumentType = List.class;
        return this;
    }

  Tensor tensor(DataType::DT_INT32, TensorShape({1}));
  std::vector<tfrt::RCReference<tfrt::AsyncValue>> arguments;
  arguments.reserve(func->argument_types().size());
  arguments.push_back(tfrt::GetReadyChain());
  for (int i = 1, e = func->argument_types().size(); i < e; ++i) {
    arguments.push_back(
        tfrt::MakeAvailableAsyncValueRef<tfrt_stub::FallbackTensor>(tensor));
  }

void RuntimeFallbackExecutor::RunTfrtInitializer() {
  const Function* func = bef_file_->GetFunction("_tfrt_fallback_init");
  CHECK(func) << "TFRT initialization function was not found";
  CHECK_EQ(func->argument_types().size(), 1);

  llvm::SmallVector<RCReference<AsyncValue>, 1> results;
  results.resize(func->result_types().size());
  CHECK_EQ(results.size(), 1);