Allow externs with no arguments and no return value

oqpy/base.py

@@ -24,7 +24,7 @@
 import math
 import sys
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Iterable, Sequence, Union
+from typing import TYPE_CHECKING, Any, Iterable, Optional, Sequence, Union
 
 import numpy as np
 from openpulse import ast
@@ -50,7 +50,7 @@ class OQPyExpression:
     ``==`` which produces a new expression instead of producing a python boolean.
     """
 
-    type: ast.ClassicalType
+    type: Optional[ast.ClassicalType]
 
     def to_ast(self, program: Program) -> ast.Expression:
         """Converts the oqpy expression into an ast node."""
@@ -175,7 +175,7 @@ def __bool__(self) -> bool:
         )
 
 
-def _get_type(val: AstConvertible) -> ast.ClassicalType:
+def _get_type(val: AstConvertible) -> Optional[ast.ClassicalType]:
     if isinstance(val, OQPyExpression):
         return val.type
     elif isinstance(val, int):

oqpy/classical_types.py

@@ -25,6 +25,7 @@
     Any,
     Callable,
     Iterable,
+    Optional,
     Sequence,
     Type,
     TypeVar,
@@ -420,7 +421,7 @@ def __init__(
         self,
         identifier: Union[str, ast.Identifier],
         args: Iterable[AstConvertible],
-        return_type: ast.ClassicalType,
+        return_type: Optional[ast.ClassicalType],
         extern_decl: ast.ExternDeclaration | None = None,
         subroutine_decl: ast.SubroutineDefinition | None = None,
     ):
@@ -429,7 +430,7 @@ def __init__(
         Args:
             identifier: The function name.
             args: The function arguments.
-            return_type: The type returned by the function call.
+            return_type: The type returned by the function call. If none, returns nothing.
             extern_decl: An optional extern declaration ast node. If present,
                 this extern declaration will be added to the top of the program
                 whenever this is converted to ast.

oqpy/subroutines.py

@@ -19,7 +19,7 @@
 
 import functools
 import inspect
-from typing import Any, Callable, Sequence, TypeVar, get_type_hints
+from typing import Any, Callable, Optional, Sequence, TypeVar, get_type_hints
 
 from mypy_extensions import VarArg
 from openpulse import ast
@@ -164,7 +164,7 @@ def wrapper(
 def declare_extern(
     name: str,
     args: list[tuple[str, ast.ClassicalType]],
-    return_type: ast.ClassicalType,
+    return_type: Optional[ast.ClassicalType] = None,
     annotations: Sequence[str | tuple[str, str]] = (),
 ) -> Callable[..., OQFunctionCall]:
     """Declare an extern and return a callable which adds the extern.
@@ -180,8 +180,8 @@ def declare_extern(
         program.set(var, sqrt(0.5))
 
     """
-    arg_names = list(zip(*(args)))[0]
-    arg_types = list(zip(*(args)))[1]
+    arg_names = list(zip(*(args)))[0] if args else []
+    arg_types = list(zip(*(args)))[1] if args else []
     extern_decl = ast.ExternDeclaration(
         ast.Identifier(name),
         [ast.ExternArgument(type=t) for t in arg_types],

tests/test_directives.py

@@ -25,8 +25,8 @@
 import numpy as np
 import pytest
 from openpulse import ast
-from openpulse.printer import dumps
 from openpulse.parser import QASMVisitor
+from openpulse.printer import dumps
 
 import oqpy
 from oqpy import *
@@ -950,6 +950,54 @@ def test_set_shift_frequency():
     _check_respects_type_hints(prog)
 
 
+def test_declare_extern():
+    program = Program()
+
+    # Test an extern with one input and output
+    sqrt = declare_extern("sqrt", [("x", float32)], float32)
+
+    # Test an extern with two inputs and one output
+    arctan = declare_extern("arctan", [("x", float32), ("y", float32)], float32)
+
+    # Test an extern with no input and one output
+    time = declare_extern("time", [], int32)
+
+    # Test an extern with one input and no output
+    set_global_voltage = declare_extern("set_voltage", [("voltage", int32)])
+
+    # Test an extern with no input and no output
+    fire_bazooka = declare_extern("fire_bazooka", [])
+
+    f = oqpy.FloatVar(name="f", init_expression=0.0)
+    i = oqpy.IntVar(name="i", init_expression=5)
+
+    program.set(f, sqrt(f))
+    program.set(f, arctan(f, f))
+    program.set(i, time())
+    program.do_expression(set_global_voltage(i))
+    program.do_expression(fire_bazooka())
+
+    expected = textwrap.dedent(
+        """
+        OPENQASM 3.0;
+        extern sqrt(float[32]) -> float[32];
+        extern arctan(float[32], float[32]) -> float[32];
+        extern time() -> int[32];
+        extern set_voltage(int[32]);
+        extern fire_bazooka();
+        float[64] f = 0.0;
+        int[32] i = 5;
+        f = sqrt(f);
+        f = arctan(f, f);
+        i = time();
+        set_voltage(i);
+        fire_bazooka();
+        """
+    ).strip()
+
+    assert program.to_qasm() == expected
+
+
 def test_defcals():
     prog = Program()
     constant = declare_waveform_generator("constant", [("length", duration), ("iq", complex128)])
@@ -1530,7 +1578,7 @@ def test_needs_declaration():
     ).strip()
 
     declared_vars = {}
-    undeclared_vars= ["i1", "i2", "f1", "f2", "q1", "q2"]
+    undeclared_vars = ["i1", "i2", "f1", "f2", "q1", "q2"]
     statement_ast = [
         ast.ClassicalAssignment(
             lvalue=ast.Identifier(name="i1"),
@@ -1745,10 +1793,10 @@ def test_in_place_subroutine_declaration():
     @subroutine(annotations=["inline", ("optimize", "-O3")])
     def f(prog: Program, x: IntVar) -> IntVar:
         return x
-    
+
     prog = Program()
     i = IntVar(0, name="i")
-    prog.declare([i,f])
+    prog.declare([i, f])
     prog.increment(i, 1)
 
     expected = textwrap.dedent(
@@ -2124,7 +2172,6 @@ def f(prog: oqpy.Program) -> oqpy.IntVar:
     def g(prog: oqpy.Program) -> oqpy.IntVar:
         return f(prog)
 
-
     prog = oqpy.Program()
     x = oqpy.IntVar(name="x")
     prog.set(x, g(prog))