string c_base_type = attr_.base_type();
  if (attr_.base_type() == "type") {
    c_base_type = "DataType";
  } else if (attr_.base_type() == "shape") {
    c_base_type = "const PartialTensorShape";
  }

  // ... and wrap in a Span<> if it's a list.
  if (attr_.is_list()) {
    return absl::Substitute("absl::Span<$0>", c_base_type);
  } else {
    return c_base_type;
  }

  return attr_.full_type();
}

    control_deps_ = std::move(control_deps);
  }

  void set_attr(AttrKeyValuePair attr) {
    DCHECK(IsEmpty());
    attr_ = std::move(attr);
  }

  bool IsEmpty() const {
    return !name().has_value() && !op().has_value() && !inputs().has_value() &&
           !control_deps().has_value() && !attr().has_value();
  }

 private:
  std::optional<string> name_;
  std::optional<string> op_;

  }

  auto attrs = attr_.getAttrs();

  if (failed(HasIntegerArrayWithSize(&func_, attrs, "pool_size", 2))) {
    return failure();
  }

  if (failed(HasIntegerArrayWithSize(&func_, attrs, "strides", 2))) {
    return failure();
  }

  // Retrieves padding.
  auto padding = mlir::dyn_cast_or_null<StringAttr>(attrs.get("padding"));
  if (!padding) {

  }

  auto attrs = attr_.getAttrs();
  if (failed(HasIntAttr(func_, attrs, "max_detections")) ||
      failed(HasIntAttr(func_, attrs, "max_classes_per_detection")) ||
      failed(HasIntAttr(func_, attrs, "num_classes")) ||
      failed(HasFloatAttr(func_, attrs, "nms_score_threshold")) ||
      failed(HasFloatAttr(func_, attrs, "nms_iou_threshold")) ||

//
// Use Group to collect several key-value pairs under a single
// key on a log line, or as the result of LogValue
// in order to log a single value as multiple Attrs.
func Group(key string, args ...any) Attr {
	return Attr{key, GroupValue(argsToAttrSlice(args)...)}
}

func argsToAttrSlice(args []any) []Attr {
	var (
		attr  Attr
		attrs []Attr
	)
	for len(args) > 0 {

        extraAttributes.contains(attr2)
        !extraAttributes.contains(attr1)
    }

    def "collects extra attributes, two candidates"() {
        def attr1 = Attribute.of("foo", String)
        def attr2 = Attribute.of("bar", String)
        def attr3 = Attribute.of("baz", String)

        given:
        ImmutableAttributes[] candidates = [
            candidate(ImmutableMap.of(attr1, "v1", attr2, "v2")),

        hasExtraAttribute(attr2)
        doesNotHaveExtraAttribute(attr1)
    }

    def "collects extra attributes, two candidates"() {
        def attr1 = Attribute.of("foo", String)
        def attr2 = Attribute.of("bar", String)
        def attr3 = Attribute.of("baz", String)

        given:
        candidate {
            attribute(attr1, "v1")
            attribute(attr2, "v2")
        }
        candidate {

}

// CHECK:        op: "NoOp"
// CHECK-NEXT:   attr
// CHECK-NEXT:     key: "_f"
// CHECK-NEXT:     value
// CHECK-NEXT:       func
// CHECK-NEXT:         name: "original_callee"
// CHECK-NEXT:         attr
// CHECK-NEXT:           key: "attr2"
// CHECK-NEXT:           value
// CHECK-NEXT:             b: true
// CHECK:              attr
// CHECK-NEXT:           key: "attr3"
// CHECK-NEXT:           value

    device: The tensorflow device. eg. "/CPU:0"
    op_attrs: The tensorflow attributes excluding the func attrs.
    op_name: The tensorflow op name. eg. "tf.AddV2"

    Example:
      tfrt_fallback_sync.createop() key(0) device("/CPU:0")
        "some.op"() {attr1 = value, attr2 = value2} {f_attr1 = "fn1", f_attr2 = "fn2"} num_args(1)
  }];

  let arguments = (ins
    StrAttr:$node_def,

  }
  attr {
    key: "_arg1_attr1"
    value {
      f: 8.0
    }
  }
  attr {
    key: "index"
    value {
      i: 1
    }
  }
}
node {
  name: "arg2"
  op: "_Arg"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
  attr {
    key: "index"
    value {
      i: 2
    }
  }
}
node {
  name: "ret0"
  op: "_Retval"
  input: "arg0"
  attr {