*op_attrs);

struct ParseExecuteOpOptions {
  bool has_chain = false;
  bool has_key = false;
  bool has_device = false;
  bool has_func_attr = false;
  bool has_cost = false;
  bool has_op_name = true;
  bool has_symbol_ref = false;
};

mlir::ParseResult ParseExecuteOpCommon(mlir::OpAsmParser &parser,
                                       mlir::Builder &builder,

      (parser.parseKeyword("device") || parser.parseLParen() ||
       parser.parseAttribute(device, "device", result.attributes) ||
       parser.parseRParen()))
    return mlir::failure();

  if (options.has_op_name &&
      parser.parseAttribute(op_name, "op_name", result.attributes))
    return mlir::failure();

  if (options.has_symbol_ref &&
      parser.parseAttribute(f, "f", result.attributes))
    return mlir::failure();

  int mlir_only_patterns = 0;
  for (auto& pattern : mlir_legalize_lower_patterns.getNativePatterns()) {
    std::optional<OperationName> pat_op_name = pattern->getRootKind();
    if (!pat_op_name) {
      continue;
    }

    if (!HasTf2XlaFallback(pat_op_name->getRegisteredInfo()->getTypeID())) {
      mlir_only_patterns++;
    }
  }

  EXPECT_EQ(mlir_only_patterns, 63);
}

  for (auto &pattern : from.getNativePatterns()) {
    std::optional<OperationName> pat_op_name = pattern->getRootKind();
    // If the pattern does not have a specific operation, always include it,
    // If the pattern is in include_ops then include it.
    bool include =
        !pat_op_name ||
        IsTypeLegalizedWithMlir(pat_op_name->getRegisteredInfo()->getTypeID());
    if (include) to.add(std::move(pattern));
  }