libqasm 1.0.0__cp39-cp39-macosx_10_9_x86_64.whl → 1.1.0__cp39-cp39-macosx_10_9_x86_64.whl

cqasm/v3x/ast.py

@@ -1174,6 +1174,8 @@ class Annotated(Node):
             return GateInstruction._deserialize(cbor, seq_to_ob, links)
         if typ == 'NonGateInstruction':
             return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'AsmDeclaration':
+            return AsmDeclaration._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -1523,6 +1525,473 @@ class MultiAnnotationData(_Multiple):
 
 _typemap['AnnotationData'] = AnnotationData
 
+class Statement(Annotated):
+    __slots__ = []
+
+    def __init__(
+        self,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ == 'Variable':
+            return Variable._deserialize(cbor, seq_to_ob, links)
+        if typ == 'GateInstruction':
+            return GateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'NonGateInstruction':
+            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'AsmDeclaration':
+            return AsmDeclaration._deserialize(cbor, seq_to_ob, links)
+        raise ValueError('unknown or unexpected type (@t) found in node serialization')
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'Statement'}
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiStatement(_Multiple):
+    """Wrapper for an edge with multiple Statement objects."""
+
+    _T = Statement
+
+
+_typemap['Statement'] = Statement
+
+class BlockStatement(Statement):
+    __slots__ = []
+
+    def __init__(
+        self,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ == 'Variable':
+            return Variable._deserialize(cbor, seq_to_ob, links)
+        if typ == 'GateInstruction':
+            return GateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'NonGateInstruction':
+            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'AsmDeclaration':
+            return AsmDeclaration._deserialize(cbor, seq_to_ob, links)
+        raise ValueError('unknown or unexpected type (@t) found in node serialization')
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'BlockStatement'}
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiBlockStatement(_Multiple):
+    """Wrapper for an edge with multiple BlockStatement objects."""
+
+    _T = BlockStatement
+
+
+_typemap['BlockStatement'] = BlockStatement
+
+class Instruction(BlockStatement):
+    __slots__ = []
+
+    def __init__(
+        self,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ == 'GateInstruction':
+            return GateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'NonGateInstruction':
+            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'AsmDeclaration':
+            return AsmDeclaration._deserialize(cbor, seq_to_ob, links)
+        raise ValueError('unknown or unexpected type (@t) found in node serialization')
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'Instruction'}
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiInstruction(_Multiple):
+    """Wrapper for an edge with multiple Instruction objects."""
+
+    _T = Instruction
+
+
+_typemap['Instruction'] = Instruction
+
+class AsmDeclaration(Instruction):
+    __slots__ = [
+        '_attr_backend_name',
+        '_attr_backend_code',
+    ]
+
+    def __init__(
+        self,
+        backend_name=None,
+        backend_code=None,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+        self.backend_name = backend_name
+        self.backend_code = backend_code
+
+    @property
+    def backend_name(self):
+        return self._attr_backend_name
+
+    @backend_name.setter
+    def backend_name(self, val):
+        if val is None:
+            del self.backend_name
+            return
+        if not isinstance(val, Identifier):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('backend_name must be of type Identifier')
+            val = Identifier(val)
+        self._attr_backend_name = val
+
+    @backend_name.deleter
+    def backend_name(self):
+        self._attr_backend_name = None
+
+    @property
+    def backend_code(self):
+        return self._attr_backend_code
+
+    @backend_code.setter
+    def backend_code(self, val):
+        if val is None:
+            del self.backend_code
+            return
+        if not isinstance(val, cqasm.v3x.primitives.Str):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('backend_code must be of type cqasm.v3x.primitives.Str')
+            val = cqasm.v3x.primitives.Str(val)
+        self._attr_backend_code = val
+
+    @backend_code.deleter
+    def backend_code(self):
+        self._attr_backend_code = cqasm.v3x.primitives.Str()
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, AsmDeclaration):
+            return False
+        if self.backend_name != other.backend_name:
+            return False
+        if self.backend_code != other.backend_code:
+            return False
+        if self.annotations != other.annotations:
+            return False
+        return True
+
+    def dump(self, indent=0, annotations=None, links=1):
+        """Returns a debug representation of this tree as a multiline string.
+        indent is the number of double spaces prefixed before every line.
+        annotations, if specified, must be a set-like object containing the key
+        strings of the annotations that are to be printed. links specifies the
+        maximum link recursion depth."""
+        s = ['  '*indent]
+        s.append('AsmDeclaration(')
+        if annotations is None:
+            annotations = []
+        for key in annotations:
+            if key in self:
+                s.append(' # {}: {}'.format(key, self[key]))
+        s.append('\n')
+        indent += 1
+        s.append('  '*indent)
+        s.append('backend_name: ')
+        if self.backend_name is None:
+            s.append('!MISSING\n')
+        else:
+            s.append('<\n')
+            s.append(self.backend_name.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('backend_code: ')
+        s.append(str(self.backend_code) + '\n')
+        s.append('  '*indent)
+        s.append('annotations: ')
+        if not self.annotations:
+            s.append('-\n')
+        else:
+            s.append('[\n')
+            for child in self.annotations:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\n')
+        indent -= 1
+        s.append('  '*indent)
+        s.append(')')
+        return ''.join(s)
+
+    __str__ = dump
+    __repr__ = dump
+
+    def find_reachable(self, id_map=None):
+        """Returns a dictionary mapping Python id() values to stable sequence
+        numbers for all nodes in the tree rooted at this node. If id_map is
+        specified, found nodes are appended to it."""
+        if id_map is None:
+            id_map = {}
+        if id(self) in id_map:
+            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
+        id_map[id(self)] = len(id_map)
+        if self._attr_backend_name is not None:
+            self._attr_backend_name.find_reachable(id_map)
+        for el in self._attr_annotations:
+            el.find_reachable(id_map)
+        return id_map
+
+    def check_complete(self, id_map=None):
+        """Raises NotWellFormed if the tree rooted at this node is not
+        well-formed. If id_map is specified, this tree is only a subtree in the
+        context of a larger tree, and id_map must be a dict mapping from Python
+        id() codes to tree indices for all reachable nodes."""
+        if id_map is None:
+            id_map = self.find_reachable()
+        if self._attr_backend_name is None:
+            raise NotWellFormed('backend_name is required but not set')
+        if self._attr_backend_name is not None:
+            self._attr_backend_name.check_complete(id_map)
+        for child in self._attr_annotations:
+            child.check_complete(id_map)
+
+    def copy(self):
+        """Returns a shallow copy of this node."""
+        return AsmDeclaration(
+            backend_name=self._attr_backend_name,
+            backend_code=self._attr_backend_code,
+            annotations=self._attr_annotations.copy()
+        )
+
+    def clone(self):
+        """Returns a deep copy of this node. This mimics the C++ interface,
+        deficiencies with links included; that is, links always point to the
+        original tree. If you're not cloning a subtree in a context where this
+        is the desired behavior, you may want to use the copy.deepcopy() from
+        the stdlib instead, which should copy links correctly."""
+        return AsmDeclaration(
+            backend_name=_cloned(self._attr_backend_name),
+            backend_code=_cloned(self._attr_backend_code),
+            annotations=_cloned(self._attr_annotations)
+        )
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ != 'AsmDeclaration':
+            raise ValueError('found node serialization for ' + typ + ', but expected AsmDeclaration')
+
+        # Deserialize the backend_name field.
+        field = cbor.get('backend_name', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field backend_name')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field backend_name')
+        if field.get('@t', None) is None:
+            f_backend_name = None
+        else:
+            f_backend_name = Identifier._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the backend_code field.
+        field = cbor.get('backend_code', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field backend_code')
+        if hasattr(cqasm.v3x.primitives.Str, 'deserialize_cbor'):
+            f_backend_code = cqasm.v3x.primitives.Str.deserialize_cbor(field)
+        else:
+            f_backend_code = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Str, field)
+
+        # Deserialize the annotations field.
+        field = cbor.get('annotations', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field annotations')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field annotations')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_annotations = MultiAnnotationData()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
+
+        # Construct the AsmDeclaration node.
+        node = AsmDeclaration(f_backend_name, f_backend_code, f_annotations)
+
+        # Deserialize annotations.
+        for key, val in cbor.items():
+            if not (key.startswith('{') and key.endswith('}')):
+                continue
+            key = key[1:-1]
+            node[key] = cqasm.v3x.primitives.deserialize(key, val)
+
+        # Register node in sequence number lookup.
+        seq = cbor.get('@i', None)
+        if not isinstance(seq, int):
+            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
+        if seq in seq_to_ob:
+            raise ValueError('duplicate sequence number %d' % seq)
+        seq_to_ob[seq] = node
+
+        return node
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'AsmDeclaration'}
+
+        # Serialize the backend_name field.
+        field = {'@T': '1'}
+        if self._attr_backend_name is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_backend_name._serialize(id_map))
+        cbor['backend_name'] = field
+
+        # Serialize the backend_code field.
+        if hasattr(self._attr_backend_code, 'serialize_cbor'):
+            cbor['backend_code'] = self._attr_backend_code.serialize_cbor()
+        else:
+            cbor['backend_code'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Str, self._attr_backend_code)
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiAsmDeclaration(_Multiple):
+    """Wrapper for an edge with multiple AsmDeclaration objects."""
+
+    _T = AsmDeclaration
+
+
+_typemap['AsmDeclaration'] = AsmDeclaration
+
 class BitwiseExpression(BinaryExpression):
     __slots__ = []
 
@@ -2500,130 +2969,6 @@ class MultiBlock(_Multiple):
 
 _typemap['Block'] = Block
 
-class Statement(Annotated):
-    __slots__ = []
-
-    def __init__(
-        self,
-        annotations=None,
-    ):
-        super().__init__(annotations=annotations)
-
-    @staticmethod
-    def _deserialize(cbor, seq_to_ob, links):
-        """Attempts to deserialize the given cbor object (in Python primitive
-        representation) into a node of this type. All (sub)nodes are added to
-        the seq_to_ob dict, indexed by their cbor sequence number. All links are
-        registered in the links list by means of a two-tuple of the setter
-        function for the link field and the sequence number of the target node.
-        """
-        if not isinstance(cbor, dict):
-            raise TypeError('node description object must be a dict')
-        typ = cbor.get('@t', None)
-        if typ is None:
-            raise ValueError('type (@t) field is missing from node serialization')
-        if typ == 'Variable':
-            return Variable._deserialize(cbor, seq_to_ob, links)
-        if typ == 'GateInstruction':
-            return GateInstruction._deserialize(cbor, seq_to_ob, links)
-        if typ == 'NonGateInstruction':
-            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
-        raise ValueError('unknown or unexpected type (@t) found in node serialization')
-
-    def _serialize(self, id_map):
-        """Serializes this node to the Python primitive representation of its
-        CBOR serialization. The tree that the node belongs to must be
-        well-formed. id_map must match Python id() calls for all nodes to unique
-        integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'Statement'}
-
-        # Serialize the annotations field.
-        field = {'@T': '*'}
-        lst = []
-        for el in self._attr_annotations:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['annotations'] = field
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiStatement(_Multiple):
-    """Wrapper for an edge with multiple Statement objects."""
-
-    _T = Statement
-
-
-_typemap['Statement'] = Statement
-
-class BlockStatement(Statement):
-    __slots__ = []
-
-    def __init__(
-        self,
-        annotations=None,
-    ):
-        super().__init__(annotations=annotations)
-
-    @staticmethod
-    def _deserialize(cbor, seq_to_ob, links):
-        """Attempts to deserialize the given cbor object (in Python primitive
-        representation) into a node of this type. All (sub)nodes are added to
-        the seq_to_ob dict, indexed by their cbor sequence number. All links are
-        registered in the links list by means of a two-tuple of the setter
-        function for the link field and the sequence number of the target node.
-        """
-        if not isinstance(cbor, dict):
-            raise TypeError('node description object must be a dict')
-        typ = cbor.get('@t', None)
-        if typ is None:
-            raise ValueError('type (@t) field is missing from node serialization')
-        if typ == 'Variable':
-            return Variable._deserialize(cbor, seq_to_ob, links)
-        if typ == 'GateInstruction':
-            return GateInstruction._deserialize(cbor, seq_to_ob, links)
-        if typ == 'NonGateInstruction':
-            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
-        raise ValueError('unknown or unexpected type (@t) found in node serialization')
-
-    def _serialize(self, id_map):
-        """Serializes this node to the Python primitive representation of its
-        CBOR serialization. The tree that the node belongs to must be
-        well-formed. id_map must match Python id() calls for all nodes to unique
-        integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'BlockStatement'}
-
-        # Serialize the annotations field.
-        field = {'@T': '*'}
-        lst = []
-        for el in self._attr_annotations:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['annotations'] = field
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiBlockStatement(_Multiple):
-    """Wrapper for an edge with multiple BlockStatement objects."""
-
-    _T = BlockStatement
-
-
-_typemap['BlockStatement'] = BlockStatement
-
 class BooleanLiteral(Expression):
     __slots__ = [
         '_attr_value',
@@ -4986,20 +5331,20 @@ class Gate(Annotated):
     __slots__ = [
         '_attr_name',
         '_attr_gate',
-        '_attr_parameter',
+        '_attr_parameters',
     ]
 
     def __init__(
         self,
         name=None,
         gate=None,
-        parameter=None,
+        parameters=None,
         annotations=None,
     ):
         super().__init__(annotations=annotations)
         self.name = name
         self.gate = gate
-        self.parameter = parameter
+        self.parameters = parameters
 
     @property
     def name(self):
@@ -5042,24 +5387,24 @@ class Gate(Annotated):
         self._attr_gate = None
 
     @property
-    def parameter(self):
-        return self._attr_parameter
+    def parameters(self):
+        return self._attr_parameters
 
-    @parameter.setter
-    def parameter(self, val):
+    @parameters.setter
+    def parameters(self, val):
         if val is None:
-            del self.parameter
+            del self.parameters
             return
-        if not isinstance(val, Expression):
+        if not isinstance(val, ExpressionList):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('parameter must be of type Expression')
-            val = Expression(val)
-        self._attr_parameter = val
+                raise TypeError('parameters must be of type ExpressionList')
+            val = ExpressionList(val)
+        self._attr_parameters = val
 
-    @parameter.deleter
-    def parameter(self):
-        self._attr_parameter = None
+    @parameters.deleter
+    def parameters(self):
+        self._attr_parameters = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -5069,7 +5414,7 @@ class Gate(Annotated):
             return False
         if self.gate != other.gate:
             return False
-        if self.parameter != other.parameter:
+        if self.parameters != other.parameters:
             return False
         if self.annotations != other.annotations:
             return False
@@ -5107,12 +5452,12 @@ class Gate(Annotated):
             s.append(self.gate.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('parameter: ')
-        if self.parameter is None:
-            s.append('-\n')
+        s.append('parameters: ')
+        if self.parameters is None:
+            s.append('!MISSING\n')
         else:
             s.append('<\n')
-            s.append(self.parameter.dump(indent + 1, annotations, links) + '\n')
+            s.append(self.parameters.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
         s.append('annotations: ')
@@ -5144,8 +5489,8 @@ class Gate(Annotated):
             self._attr_name.find_reachable(id_map)
         if self._attr_gate is not None:
             self._attr_gate.find_reachable(id_map)
-        if self._attr_parameter is not None:
-            self._attr_parameter.find_reachable(id_map)
+        if self._attr_parameters is not None:
+            self._attr_parameters.find_reachable(id_map)
         for el in self._attr_annotations:
             el.find_reachable(id_map)
         return id_map
@@ -5163,8 +5508,10 @@ class Gate(Annotated):
             self._attr_name.check_complete(id_map)
         if self._attr_gate is not None:
             self._attr_gate.check_complete(id_map)
-        if self._attr_parameter is not None:
-            self._attr_parameter.check_complete(id_map)
+        if self._attr_parameters is None:
+            raise NotWellFormed('parameters is required but not set')
+        if self._attr_parameters is not None:
+            self._attr_parameters.check_complete(id_map)
         for child in self._attr_annotations:
             child.check_complete(id_map)
 
@@ -5173,7 +5520,7 @@ class Gate(Annotated):
         return Gate(
             name=self._attr_name,
             gate=self._attr_gate,
-            parameter=self._attr_parameter,
+            parameters=self._attr_parameters,
             annotations=self._attr_annotations.copy()
         )
 
@@ -5186,7 +5533,7 @@ class Gate(Annotated):
         return Gate(
             name=_cloned(self._attr_name),
             gate=_cloned(self._attr_gate),
-            parameter=_cloned(self._attr_parameter),
+            parameters=_cloned(self._attr_parameters),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -5228,16 +5575,16 @@ class Gate(Annotated):
         else:
             f_gate = Gate._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the parameter field.
-        field = cbor.get('parameter', None)
+        # Deserialize the parameters field.
+        field = cbor.get('parameters', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field parameter')
-        if field.get('@T') != '?':
-            raise ValueError('unexpected edge type for field parameter')
+            raise ValueError('missing or invalid serialization of field parameters')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field parameters')
         if field.get('@t', None) is None:
-            f_parameter = None
+            f_parameters = None
         else:
-            f_parameter = Expression._deserialize(field, seq_to_ob, links)
+            f_parameters = ExpressionList._deserialize(field, seq_to_ob, links)
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -5255,7 +5602,7 @@ class Gate(Annotated):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the Gate node.
-        node = Gate(f_name, f_gate, f_parameter, f_annotations)
+        node = Gate(f_name, f_gate, f_parameters, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -5297,13 +5644,13 @@ class Gate(Annotated):
             field.update(self._attr_gate._serialize(id_map))
         cbor['gate'] = field
 
-        # Serialize the parameter field.
-        field = {'@T': '?'}
-        if self._attr_parameter is None:
+        # Serialize the parameters field.
+        field = {'@T': '1'}
+        if self._attr_parameters is None:
             field['@t'] = None
         else:
-            field.update(self._attr_parameter._serialize(id_map))
-        cbor['parameter'] = field
+            field.update(self._attr_parameters._serialize(id_map))
+        cbor['parameters'] = field
 
         # Serialize the annotations field.
         field = {'@T': '*'}
@@ -5330,66 +5677,6 @@ class MultiGate(_Multiple):
 
 _typemap['Gate'] = Gate
 
-class Instruction(BlockStatement):
-    __slots__ = []
-
-    def __init__(
-        self,
-        annotations=None,
-    ):
-        super().__init__(annotations=annotations)
-
-    @staticmethod
-    def _deserialize(cbor, seq_to_ob, links):
-        """Attempts to deserialize the given cbor object (in Python primitive
-        representation) into a node of this type. All (sub)nodes are added to
-        the seq_to_ob dict, indexed by their cbor sequence number. All links are
-        registered in the links list by means of a two-tuple of the setter
-        function for the link field and the sequence number of the target node.
-        """
-        if not isinstance(cbor, dict):
-            raise TypeError('node description object must be a dict')
-        typ = cbor.get('@t', None)
-        if typ is None:
-            raise ValueError('type (@t) field is missing from node serialization')
-        if typ == 'GateInstruction':
-            return GateInstruction._deserialize(cbor, seq_to_ob, links)
-        if typ == 'NonGateInstruction':
-            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
-        raise ValueError('unknown or unexpected type (@t) found in node serialization')
-
-    def _serialize(self, id_map):
-        """Serializes this node to the Python primitive representation of its
-        CBOR serialization. The tree that the node belongs to must be
-        well-formed. id_map must match Python id() calls for all nodes to unique
-        integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'Instruction'}
-
-        # Serialize the annotations field.
-        field = {'@T': '*'}
-        lst = []
-        for el in self._attr_annotations:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['annotations'] = field
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiInstruction(_Multiple):
-    """Wrapper for an edge with multiple Instruction objects."""
-
-    _T = Instruction
-
-
-_typemap['Instruction'] = Instruction
-
 class GateInstruction(Instruction):
     __slots__ = [
         '_attr_gate',
@@ -8387,20 +8674,20 @@ class NonGateInstruction(Instruction):
     __slots__ = [
         '_attr_name',
         '_attr_operands',
-        '_attr_parameter',
+        '_attr_parameters',
     ]
 
     def __init__(
         self,
         name=None,
         operands=None,
-        parameter=None,
+        parameters=None,
         annotations=None,
     ):
         super().__init__(annotations=annotations)
         self.name = name
         self.operands = operands
-        self.parameter = parameter
+        self.parameters = parameters
 
     @property
     def name(self):
@@ -8443,24 +8730,24 @@ class NonGateInstruction(Instruction):
         self._attr_operands = None
 
     @property
-    def parameter(self):
-        return self._attr_parameter
+    def parameters(self):
+        return self._attr_parameters
 
-    @parameter.setter
-    def parameter(self, val):
+    @parameters.setter
+    def parameters(self, val):
         if val is None:
-            del self.parameter
+            del self.parameters
             return
-        if not isinstance(val, Expression):
+        if not isinstance(val, ExpressionList):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('parameter must be of type Expression')
-            val = Expression(val)
-        self._attr_parameter = val
+                raise TypeError('parameters must be of type ExpressionList')
+            val = ExpressionList(val)
+        self._attr_parameters = val
 
-    @parameter.deleter
-    def parameter(self):
-        self._attr_parameter = None
+    @parameters.deleter
+    def parameters(self):
+        self._attr_parameters = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -8470,7 +8757,7 @@ class NonGateInstruction(Instruction):
             return False
         if self.operands != other.operands:
             return False
-        if self.parameter != other.parameter:
+        if self.parameters != other.parameters:
             return False
         if self.annotations != other.annotations:
             return False
@@ -8508,12 +8795,12 @@ class NonGateInstruction(Instruction):
             s.append(self.operands.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('parameter: ')
-        if self.parameter is None:
-            s.append('-\n')
+        s.append('parameters: ')
+        if self.parameters is None:
+            s.append('!MISSING\n')
         else:
             s.append('<\n')
-            s.append(self.parameter.dump(indent + 1, annotations, links) + '\n')
+            s.append(self.parameters.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
         s.append('annotations: ')
@@ -8545,8 +8832,8 @@ class NonGateInstruction(Instruction):
             self._attr_name.find_reachable(id_map)
         if self._attr_operands is not None:
             self._attr_operands.find_reachable(id_map)
-        if self._attr_parameter is not None:
-            self._attr_parameter.find_reachable(id_map)
+        if self._attr_parameters is not None:
+            self._attr_parameters.find_reachable(id_map)
         for el in self._attr_annotations:
             el.find_reachable(id_map)
         return id_map
@@ -8566,8 +8853,10 @@ class NonGateInstruction(Instruction):
             raise NotWellFormed('operands is required but not set')
         if self._attr_operands is not None:
             self._attr_operands.check_complete(id_map)
-        if self._attr_parameter is not None:
-            self._attr_parameter.check_complete(id_map)
+        if self._attr_parameters is None:
+            raise NotWellFormed('parameters is required but not set')
+        if self._attr_parameters is not None:
+            self._attr_parameters.check_complete(id_map)
         for child in self._attr_annotations:
             child.check_complete(id_map)
 
@@ -8576,7 +8865,7 @@ class NonGateInstruction(Instruction):
         return NonGateInstruction(
             name=self._attr_name,
             operands=self._attr_operands,
-            parameter=self._attr_parameter,
+            parameters=self._attr_parameters,
             annotations=self._attr_annotations.copy()
         )
 
@@ -8589,7 +8878,7 @@ class NonGateInstruction(Instruction):
         return NonGateInstruction(
             name=_cloned(self._attr_name),
             operands=_cloned(self._attr_operands),
-            parameter=_cloned(self._attr_parameter),
+            parameters=_cloned(self._attr_parameters),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -8631,16 +8920,16 @@ class NonGateInstruction(Instruction):
         else:
             f_operands = ExpressionList._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the parameter field.
-        field = cbor.get('parameter', None)
+        # Deserialize the parameters field.
+        field = cbor.get('parameters', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field parameter')
-        if field.get('@T') != '?':
-            raise ValueError('unexpected edge type for field parameter')
+            raise ValueError('missing or invalid serialization of field parameters')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field parameters')
         if field.get('@t', None) is None:
-            f_parameter = None
+            f_parameters = None
         else:
-            f_parameter = Expression._deserialize(field, seq_to_ob, links)
+            f_parameters = ExpressionList._deserialize(field, seq_to_ob, links)
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -8658,7 +8947,7 @@ class NonGateInstruction(Instruction):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the NonGateInstruction node.
-        node = NonGateInstruction(f_name, f_operands, f_parameter, f_annotations)
+        node = NonGateInstruction(f_name, f_operands, f_parameters, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -8700,13 +8989,13 @@ class NonGateInstruction(Instruction):
             field.update(self._attr_operands._serialize(id_map))
         cbor['operands'] = field
 
-        # Serialize the parameter field.
-        field = {'@T': '?'}
-        if self._attr_parameter is None:
+        # Serialize the parameters field.
+        field = {'@T': '1'}
+        if self._attr_parameters is None:
             field['@t'] = None
         else:
-            field.update(self._attr_parameter._serialize(id_map))
-        cbor['parameter'] = field
+            field.update(self._attr_parameters._serialize(id_map))
+        cbor['parameters'] = field
 
         # Serialize the annotations field.
         field = {'@T': '*'}