Refactor: Introduce OpBuilderBase/TapeBuilder as unified op-building interface (#2905)

## Summary

Introduces `OpBuilderBase` (ABC) and `TapeBuilder` (concrete
implementation) as the unified interface for building IR nodes across
the rewriter, optimizer, and version converter. This is a step towards
unifying these builders with the recently introduced GraphBuilder. As of
now, there is still some differences internally (as these are oriented
towards incrementally modifying an existing graph), but for end-users
(eg., writing rewrite-rules) we should be able to move towards same API.

## Changes

### New: `onnxscript/tape_builder.py`
- **`OpBuilderBase`** — Abstract base class providing the op-building
API:
  - Dynamic dispatch: `op.Relu(x)`, `op.MatMul(a, b, _domain=...)`
  - Explicit creation: `op.op("Conv", inputs, attributes, domain=...)`
  - Initializer creation: `op.initializer(tensor, name=...)`
- Subclasses implement `_add_node`, `_add_initializer`, `_record_opset`
- **`TapeBuilder`** — Concrete subclass with list-based storage and
harvesting properties (`nodes`, `initializers`, `used_opsets`)
- Both are exported as public names from `onnxscript`

### Rewriter
- `rewriter/_context.py` slimmed to re-exports + local alias
`RewriterContext = OpBuilderBase`
- `_rewrite_rule.py` uses `TapeBuilder()` directly; harvests from the
context
- Deleted `_node_sink.py` (the intermediate NodeSink/TapeSink layer)

### Optimizer
- `optimizer/_constant_folding.py` defines `OptimizerContext =
OpBuilderBase` locally
- Uses `TapeBuilder()` instead of the old `_tape.Builder()`

### Version Converter
- `version_converter/_version_converter.py` defines `VCContext =
OpBuilderBase` locally
- Uses `TapeBuilder()` instead of the old `_tape.Builder()`

### Cleanup
- Deleted `onnxscript/ir/_tape.py` and `_tape_test.py` (fully
superseded)
- Removed incorrect `ir.Value` type annotations from `pattern()` method
signatures in rule files (pattern methods work with pattern-value
objects, not `ir.Value`)

## Design

```
OpBuilderBase (ABC)          <- shared interface
  _add_node()                <- abstract
  _add_initializer()         <- abstract
  _record_opset()            <- abstract
  __getattr__()              <- dynamic dispatch (concrete)
  op()                       <- explicit node creation (concrete)
  initializer()              <- initializer creation (concrete)

TapeBuilder(OpBuilderBase)   <- list-backed implementation
  nodes                      <- harvesting property
  initializers               <- harvesting property
  used_opsets                <- harvesting property

Aliases:
  RewriterContext  = OpBuilderBase  (in rewriter)
  OptimizerContext = OpBuilderBase  (in optimizer)
  VCContext        = OpBuilderBase  (in version converter)
```

This design allows future alternative implementations (e.g.,
graph-backed builder) by subclassing `OpBuilderBase` without changing
rule/evaluator code.

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: gramalingam

onnxscript/__init__.py

@@ -14,6 +14,8 @@
     "TracedOnnxFunction",
     "GraphBuilder",
     "OpBuilder",
+    "OpBuilderBase",
+    "TapeBuilder",
     "proto2python",
     "external_tensor",
     "BFLOAT16",
@@ -131,6 +133,7 @@
 
 from . import ir, nn, optimizer, rewriter, version_converter
 from ._internal.builder import GraphBuilder, OpBuilder
+from ._internal.tape_builder import OpBuilderBase, TapeBuilder
 from ._internal.utils import external_tensor
 from ._internal.values import OnnxFunction, TracedOnnxFunction
 

onnxscript/_internal/tape_builder.py

@@ -0,0 +1,207 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""Op builder base class and tape-backed implementation.
+
+This module defines:
+
+- ``OpBuilderBase``: Abstract base class for building ONNX IR nodes via a
+  dynamic dispatch interface (``op.Relu(x)``, ``op.op(...)``, ``op.initializer(...)``).
+  Subclasses implement the storage strategy by overriding ``_add_node``,
+  ``_add_initializer``, and ``_record_opset``.
+
+- ``TapeBuilder``: Concrete subclass backed by simple lists.  Engines
+  (rewriter, optimizer, version converter) create an instance, pass it to a
+  rule or evaluator, and harvest the accumulated nodes / initializers / opsets
+  after it returns.
+"""
+
+from __future__ import annotations
+
+import abc
+from typing import Any, Mapping, Optional, Sequence
+
+import onnx_ir as ir
+from onnx_ir import _convenience
+
+UsedOpsets = set[tuple[str, Optional[int]]]
+
+
+class OpBuilderBase(abc.ABC):
+    """Abstract base class for building ONNX IR nodes.
+
+    Supports three creation operations:
+
+    1. **Dynamic op dispatch** — ``op.Relu(x)``, ``op.MatMul(a, b, _domain=...)``, etc.
+    2. **Explicit op creation** — ``op.op("Conv", inputs, attrs, domain=...)``.
+    3. **Initializer creation** — ``op.initializer(tensor, name=...)``.
+
+    Subclasses must implement the three protected methods that define where
+    created nodes and initializers are stored:
+
+    - :meth:`_add_node`
+    - :meth:`_add_initializer`
+    - :meth:`_record_opset`
+    """
+
+    # ------------------------------------------------------------------
+    # Abstract storage interface (to be implemented by subclasses)
+    # ------------------------------------------------------------------
+
+    @abc.abstractmethod
+    def _add_node(self, node: ir.Node) -> None:
+        """Record a newly created node."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _add_initializer(self, value: ir.Value) -> None:
+        """Record a newly created initializer."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _record_opset(self, domain: str, version: int | None) -> None:
+        """Record that an opset domain/version was referenced."""
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------
+    # Public API (concrete)
+    # ------------------------------------------------------------------
+
+    def __getattr__(self, op_type: str) -> Any:
+        """Dynamic op dispatch: ``op.Relu(x)``, ``op.MatMul(a, b)``, etc.
+
+        Returns a callable that creates a node of the given ``op_type``
+        and records it via the subclass storage implementation.
+
+        Supported keyword arguments on the returned callable:
+            _domain (str): Op domain (default ``""``).
+            _version (int | None): Opset version.
+            _outputs (int | list[str]): Number of outputs or explicit output names.
+            _name (str | None): Optional node name (must be unique).
+        """
+        return lambda *args, **kwargs: self._make_node(op_type, args, kwargs)
+
+    def _make_node(
+        self, op_type: str, inputs: Sequence[ir.Value | None], kwargs: dict[str, Any]
+    ) -> ir.Value | Sequence[ir.Value]:
+        """Create one or more output values by building an ``ir.Node``."""
+        domain = kwargs.pop("_domain", "")
+        version = kwargs.pop("_version", None)
+        outputs = kwargs.pop("_outputs", 1)
+        name = kwargs.pop("_name", None)
+
+        if isinstance(outputs, Sequence):
+            num_outputs = len(outputs)
+        else:
+            assert isinstance(outputs, int)
+            num_outputs = outputs
+
+        attrs: Sequence[ir.Attr] = _convenience.convert_attributes(kwargs) if kwargs else ()
+        node = ir.Node(
+            domain,
+            op_type,
+            inputs,
+            attributes=attrs,
+            num_outputs=num_outputs,
+            version=version,
+            name=name,
+        )
+        self._add_node(node)
+        self._record_opset(domain, version)
+
+        if num_outputs == 1:
+            if isinstance(outputs, Sequence):
+                node.outputs[0].name = outputs[0]
+            return node.outputs[0]
+
+        if isinstance(outputs, Sequence):
+            for value, output_name in zip(node.outputs, outputs):
+                value.name = output_name
+        return node.outputs
+
+    def op(
+        self,
+        op_type: str,
+        inputs: Sequence[ir.Value | None],
+        attributes: Mapping[str, _convenience.SupportedAttrTypes] | None = None,
+        *,
+        domain: str = "",
+        version: int | None = None,
+        name: str | None = None,
+    ) -> ir.Value:
+        """Create a single-output node with an explicit op type.
+
+        This is useful when the op type is determined dynamically or when
+        forwarding attributes from a matched node.
+        """
+        attrs: Sequence[ir.Attr] = (
+            _convenience.convert_attributes(attributes) if attributes else ()
+        )
+        node = ir.Node(
+            domain,
+            op_type,
+            inputs,
+            attributes=attrs,
+            num_outputs=1,
+            version=version,
+            name=name,
+        )
+        self._add_node(node)
+        self._record_opset(domain, version)
+        return node.outputs[0]
+
+    def initializer(
+        self,
+        tensor: ir.TensorProtocol,
+        name: str | None = None,
+    ) -> ir.Value:
+        """Create a new constant initializer and return its ``ir.Value``."""
+        name = name or tensor.name
+        if name is None:
+            raise ValueError("Name must be provided for initializer.")
+        shape = ir.Shape((d if isinstance(d, int) else d.value) for d in tensor.shape.dims)
+        value = ir.Value(
+            name=name, shape=shape, type=ir.TensorType(tensor.dtype), const_value=tensor
+        )
+        self._add_initializer(value)
+        return value
+
+
+class TapeBuilder(OpBuilderBase):
+    """Concrete builder backed by simple lists (tape-like storage).
+
+    Engines (rewriter, optimizer, version converter) create an instance,
+    pass it to a rule or evaluator, and after it returns, harvest the
+    accumulated results via the ``nodes``, ``initializers``, and
+    ``used_opsets`` properties.
+    """
+
+    def __init__(self) -> None:
+        self._nodes: list[ir.Node] = []
+        self._initializers: list[ir.Value] = []
+        self._used_opsets: UsedOpsets = set()
+
+    def _add_node(self, node: ir.Node) -> None:
+        self._nodes.append(node)
+
+    def _add_initializer(self, value: ir.Value) -> None:
+        self._initializers.append(value)
+
+    def _record_opset(self, domain: str, version: int | None) -> None:
+        self._used_opsets.add((domain, version))
+
+    # --- Harvesting properties ---
+
+    @property
+    def nodes(self) -> Sequence[ir.Node]:
+        """All nodes created during this context's lifetime."""
+        return tuple(self._nodes)
+
+    @property
+    def initializers(self) -> Sequence[ir.Value]:
+        """All initializers created during this context's lifetime."""
+        return tuple(self._initializers)
+
+    @property
+    def used_opsets(self) -> UsedOpsets:
+        """Opset domains/versions referenced by created nodes."""
+        return self._used_opsets