Simple OpenQASM 3.0 expressions and casts

doc/releases/changelog-dev.md

@@ -9,6 +9,7 @@
   [(#7432)](https://github.com/PennyLaneAI/pennylane/pull/7432)
   [(#7486)](https://github.com/PennyLaneAI/pennylane/pull/7486)
   [(#7488)](https://github.com/PennyLaneAI/pennylane/pull/7488)
+  [(#7593)](https://github.com/PennyLaneAI/pennylane/pull/7593)
 
   ```python
   import pennylane as qml

pennylane/io/qasm_interpreter.py

@@ -7,25 +7,35 @@
 from functools import partial
 from typing import Any, Iterable
 
+from numpy import uint
 from openqasm3.ast import (
     AliasStatement,
     ArrayLiteral,
+    BinaryExpression,
     BitstringLiteral,
     BooleanLiteral,
+    BoolType,
+    Cast,
     ClassicalAssignment,
     ClassicalDeclaration,
+    ComplexType,
     ConstantDeclaration,
     DurationLiteral,
     EndStatement,
     Expression,
+    ExpressionStatement,
     FloatLiteral,
+    FloatType,
     Identifier,
     ImaginaryLiteral,
     IndexExpression,
     IntegerLiteral,
+    IntType,
     QuantumGate,
     QubitDeclaration,
     RangeDefinition,
+    UintType,
+    UnaryExpression,
 )
 from openqasm3.visitor import QASMNode
 
@@ -126,28 +136,55 @@ def retrieve_variable(self, name: str):
         raise TypeError(f"Attempt to use undeclared variable {name} in {self.name}")
 
     def update_var(
-        self,
-        value: any,
-        name: str,
-        node: QASMNode,
-    ):
+        self, value: any, name: str, operator: str, line: int
+    ):  # pylint: disable=too-many-branches
         """
         Updates a variable, or raises if it is constant.
         Args:
             value (any): the value to set.
             name (str): the name of the variable.
-            node (QASMNode): the QASMNode that corresponds to the update.
+            operator (str): the assignment operator.
+            line (int): the line number at which we encountered the assignment node.
         """
-        if name in self.vars:
-            if self.vars[name].constant:
-                raise ValueError(
-                    f"Attempt to mutate a constant {name} on line {node.span.start_line} that was "
-                    f"defined on line {self.vars[name].line}"
-                )
-            self.vars[name].val = value
-            self.vars[name].line = node.span.start_line
-        else:
+        if name not in self.vars:
             raise TypeError(f"Attempt to use undeclared variable {name} in {self.name}")
+        if self.vars[name].constant:
+            raise ValueError(
+                f"Attempt to mutate a constant {name} on line {line} that was "
+                f"defined on line {self.vars[name].line}"
+            )
+        match operator:
+            case "=":
+                self.vars[name].val = value
+            case "+=":
+                self.vars[name].val += value
+            case "-=":
+                self.vars[name].val -= value
+            case "*=":
+                self.vars[name].val = self.vars[name].val * value
+            case "/=":
+                self.vars[name].val = self.vars[name].val / value
+            case "&=":
+                self.vars[name].val = self.vars[name].val & value
+            case "|=":
+                self.vars[name].val = self.vars[name].val | value
+            case "^=":
+                self.vars[name].val = self.vars[name].val ^ value
+            case "<<=":
+                self.vars[name].val = self.vars[name].val << value
+            case ">>=":
+                self.vars[name].val = self.vars[name].val >> value
+            case "%=":
+                self.vars[name].val = self.vars[name].val % value
+            case "**=":
+                self.vars[name].val = self.vars[name].val ** value
+            case _:  # pragma: no cover
+                # we shouldn't ever get this error if the parser did its job right
+                raise SyntaxError(  # pragma: no cover
+                    f"Invalid operator {operator} encountered in assignment expression "
+                    f"on line {line}."
+                )  # pragma: no cover
+        self.vars[name].line = line
 
     def require_wires(self, wires: list):
         """
@@ -205,6 +242,24 @@ def _resolve_name(node: QASMNode):
     return node.name if isinstance(node.name, str) else node.name.name
 
 
+def preprocess_operands(operand):
+    """
+    Interprets a string operand as an appropriate type.
+
+    Args:
+        operand (str): the string operand to interpret.
+
+    Returns:
+        The interpreted operand as an appropriate type.
+    """
+    if isinstance(operand, str):
+        if operand.isdigit():
+            operand = int(operand)
+        elif operand.replace(".", "").isnumeric():
+            operand = float(operand)
+    return operand
+
+
 class EndProgram(Exception):
     """Exception raised when it encounters an end statement in the QASM circuit."""
 
@@ -335,8 +390,7 @@ def visit_classical_assignment(self, node: QASMNode, context: Context):
         # references to an unresolved value see a func for now
         name = _resolve_name(node.lvalue)
         res = self.visit(node.rvalue, context)
-        # TODO: different types of assignments
-        context.update_var(res, name, node)
+        context.update_var(res, name, node.op.name, node.span.start_line)
 
     @visit.register(AliasStatement)
     def visit_alias_statement(self, node: QASMNode, context: Context):
@@ -513,6 +567,138 @@ def apply_modifier(self, mod: QuantumGate, previous: Operator, context: Context,
 
         return next, wires
 
+    @visit.register(ExpressionStatement)
+    def visit_expression_statement(self, node: ExpressionStatement, context: Context):
+        """
+        Registers an expression statement.
+        Args:
+            node (ExpressionStatement): The expression statement.
+            context (Context): The current context.
+        """
+        return self.visit(node.expression, context)
+
+    @visit.register(Cast)
+    def visit_cast(self, node: Cast, context: Context):
+        """
+        Registers a Cast expression.
+
+        Args:
+            node (Cast): The Cast expression.
+            context (Context): The current context.
+
+        Returns:
+            Any: The argument cast to the appropriate type.
+
+        Raises:
+            TypeError: If the cast cannot be made.
+        """
+        arg = self.visit(node.argument, context)
+        ret = arg
+        try:
+            if isinstance(node.type, IntType):
+                ret = int(arg)
+            if isinstance(node.type, UintType):
+                ret = uint(arg)
+            if isinstance(node.type, FloatType):
+                ret = float(arg)
+            if isinstance(node.type, ComplexType):
+                ret = complex(arg)
+            if isinstance(node.type, BoolType):
+                ret = bool(arg)
+            # TODO: durations, angles, etc.
+        except TypeError as e:
+            raise TypeError(
+                f"Unable to cast {arg.__class__.__name__} to {node.type.__class__.__name__}: {str(e)}"
+            ) from e
+        return ret
+
+    @visit.register(BinaryExpression)
+    def visit_binary_expression(
+        self, node: BinaryExpression, context: Context
+    ):  # pylint: disable=too-many-branches, too-many-return-statements
+        """
+        Registers a binary expression.
+
+        Args:
+            node (BinaryExpression): The binary expression.
+            context (Context): The current context.
+
+        Returns:
+            The result of the evaluated expression.
+        """
+        lhs = preprocess_operands(self.visit(node.lhs, context))
+        rhs = preprocess_operands(self.visit(node.rhs, context))
+        match node.op.name:
+            case "==":
+                return lhs == rhs
+            case "!=":
+                return lhs != rhs
+            case ">":
+                return lhs > rhs
+            case "<":
+                return lhs < rhs
+            case ">=":
+                return lhs >= rhs
+            case "<=":
+                return lhs <= rhs
+            case ">>":
+                return lhs >> rhs
+            case "<<":
+                return lhs << rhs
+            case "+":
+                return lhs + rhs
+            case "-":
+                return lhs - rhs
+            case "*":
+                return lhs * rhs
+            case "**":
+                return lhs**rhs
+            case "/":
+                return lhs / rhs
+            case "%":
+                return lhs % rhs
+            case "|":
+                return lhs | rhs
+            case "||":
+                return lhs or rhs
+            case "&":
+                return lhs & rhs
+            case "&&":
+                return lhs and rhs
+            case "^":
+                return lhs ^ rhs
+            case _:  # pragma: no cover
+                # we shouldn't ever get this error if the parser did its job right
+                raise SyntaxError(  # pragma: no cover
+                    f"Invalid operator {node.op.name} encountered in binary expression "
+                    f"on line {node.span.start_line}."
+                )  # pragma: no cover
+
+    @visit.register(UnaryExpression)
+    def visit_unary_expression(self, node: UnaryExpression, context: Context):
+        """
+        Registers a unary expression.
+
+        Args:
+            node (UnaryExpression): The unary expression.
+            context (Context): The current context.
+
+        Returns:
+            The result of the evaluated expression.
+        """
+        operand = preprocess_operands(self.visit(node.expression, context))
+        if node.op.name == "!":
+            return not operand
+        if node.op.name == "-":
+            return -operand
+        if node.op.name == "~":
+            return ~operand  # pylint: disable=invalid-unary-operand-type
+        # we shouldn't ever get this error if the parser did its job right
+        raise SyntaxError(  # pragma: no cover
+            f"Invalid operator {node.op.name} encountered in unary expression "
+            f"on line {node.span.start_line}."
+        )  # pragma: no cover
+
     @visit.register(IndexExpression)
     def visit_index_expression(
         self, node: IndexExpression, context: Context, aliasing: bool = False

tests/io/qasm_interpreter/assignment.qasm

@@ -0,0 +1,24 @@
+int a = 0;
+int b = 1;
+int c = 2;
+int d = 3;
+int e = 4;
+bool f = true;
+bool g = true;
+bit i = "10";
+bit j = "10";
+bit k = "11";
+int l = 5;
+int m = 6;
+a = 1;
+b += 2;
+c -= 3;
+d *= 4;
+e /= 5;
+f &= true;
+g |= false;
+i ^= 9;
+j <<= 10;
+k >>= 1;
+l %= 2;
+m **= 13;

tests/io/qasm_interpreter/binary_expressions.qasm

@@ -0,0 +1,30 @@
+const int lhs = 0;
+const int rhs = 1;
+bool a = lhs == rhs;
+bool b = lhs != rhs;
+bool c = lhs > rhs;
+bool d = lhs < rhs;
+bool e = lhs >= rhs;
+bool f = lhs <= rhs;
+
+bit lh = "10";
+bit rh = "01";
+bit g = lh >> rh;
+bit h = lh << rh;
+bit i = lh | rh;
+bit j = lh ^ rh;
+bit k = lh & rh;
+
+int l = 3;
+int r = 2;
+int m = l + r;
+int n = l / r;
+int o = l - r;
+int p = l * r;
+int q = l ** r;
+int s = l % r;
+
+bool left = true;
+bool right = false;
+int t = left || right;
+int u = left && right;

tests/io/qasm_interpreter/classical.qasm

@@ -1,8 +1,11 @@
 int i = 4;
 const int j = i;
+const int neg = -j;
 bit[3] c = "000";
 let alias = c;
+const bit k = j + alias;
 const float[3] arr = {0.0, 1.0, 2.0};
 let arr_alias = arr[0:2];
 let literal_alias = arr[0];
-complex[float[64]] comp = 3.5im;
+complex[float[64]] comp;
+comp = 2.5 + 3.5im;