Strengthen compatibility checks across Python interop (#4000)

This change adds stronger checks across the Python interop boundary to
reject two important classes of unsupported interop that can lead to
bugs:
- Invoking callables with functors (`Adjoint` and `Controlled`), which
don't make sense from the Python level as those would need `Qubit`
arguments and that type is not allowed across the interop boundary.
- Invoking callables or passing callable arguments that include generic
type parameters, as that could allow unconstrained or mismatched
generics to make it deeper into the compilation (we don't perform type
inference for generics after the fact).

Author: swernli

source/qdk_package/src/interpreter.rs

@@ -17,7 +17,7 @@ use crate::{
         get_program_type, get_search_path, sanitize_name,
     },
     interpreter::data_interop::{
-        PrimitiveKind, TypeIR, TypeKind, UdtFields, UdtIR, UdtValue, collect_udt_fields,
+        PrimitiveKind, TypeIR, TypeKind, UdtFields, UdtIR, UdtValue, first_unsupported_interop_ty,
         pyobj_to_value, type_ir_from_qsharp_ty, value_to_pyobj,
     },
     noisy_simulator::register_noisy_simulator_submodule,
@@ -44,11 +44,11 @@ use pyo3::{
     types::{PyBool, PyDict, PyList, PyString, PyTuple, PyType},
 };
 use qsc::{
-    LanguageFeatures, PackageType, SourceMap,
+    FunctorApp, LanguageFeatures, PackageType, SourceMap,
     circuit::{TracerConfig, circuit_to_standalone_qsharp, circuits_to_qsharp},
     error::WithSource,
     fir::{self},
-    hir::ty::{Prim, Ty},
+    hir::ty::Ty,
     interpret::{
         self, CircuitEntryPoint, PackageGlobal, PauliNoise, SimType, TaggedItem, Value,
         output::{Error, Receiver},
@@ -1119,12 +1119,12 @@ fn args_to_values(
 ) -> PyResult<Value> {
     // If the types are not supported, we can't convert the arguments or return value.
     // Check this before trying to convert the arguments, and return an error if the types are not supported.
-    if let Some(ty) = first_unsupported_interop_ty(ctx, input_ty) {
+    if let Some(ty) = first_unsupported_interop_ty(ctx, input_ty, false) {
         return Err(QSharpError::new_err(format!(
             "unsupported input type: `{ty}`"
         )));
     }
-    if let Some(ty) = first_unsupported_interop_ty(ctx, output_ty) {
+    if let Some(ty) = first_unsupported_interop_ty(ctx, output_ty, false) {
         return Err(QSharpError::new_err(format!(
             "unsupported output type: `{ty}`"
         )));
@@ -1148,65 +1148,34 @@ fn args_to_values(
     }
 }
 
-/// Finds any Q# type recursively that does not support interop with Python, meaning our code cannot convert it back and forth
-/// across the interop boundary.
-fn first_unsupported_interop_ty<'ctx, 'ty>(
-    ctx: &'ctx interpret::Interpreter,
-    ty: &'ty Ty,
-) -> Option<&'ctx Ty>
-where
-    'ty: 'ctx,
-{
-    match ty {
-        Ty::Prim(prim_ty) => match prim_ty {
-            Prim::Pauli
-            | Prim::BigInt
-            | Prim::Bool
-            | Prim::Double
-            | Prim::Int
-            | Prim::String
-            | Prim::Result => None,
-            Prim::Qubit | Prim::Range | Prim::RangeTo | Prim::RangeFrom | Prim::RangeFull => {
-                Some(ty)
-            }
-        },
-        Ty::Tuple(tup) => tup
-            .iter()
-            .find(|t| first_unsupported_interop_ty(ctx, t).is_some()),
-        Ty::Array(ty) => first_unsupported_interop_ty(ctx, ty),
-        Ty::Udt(_, res) => {
-            let qsc::hir::Res::Item(item_id) = res else {
-                panic!("Udt should be an item");
-            };
-            let (udt, _) = ctx.udt_ty_from_item_id(item_id);
-
-            let Ok(fields) = collect_udt_fields(udt) else {
-                return Some(ty);
-            };
-
-            for field in fields {
-                if let Some(ty) = first_unsupported_interop_ty(ctx, field.1) {
-                    return Some(ty);
-                }
-            }
-
-            None
-        }
-        Ty::Arrow(..) => None,
-        Ty::Infer(..) | Ty::Param { .. } | Ty::Err => Some(ty),
-    }
-}
-
 fn extract_callable_value(py: Python, callable: &Py<PyAny>) -> PyResult<Value> {
-    if let Ok(global_callable) = callable.extract::<GlobalCallable>(py) {
-        Ok(global_callable.0)
+    let callable_val = if let Ok(global_callable) = callable.extract::<GlobalCallable>(py) {
+        global_callable.0
     } else if let Ok(closure) = callable.extract::<Closure>(py) {
-        Ok(closure.0)
+        closure.0
     } else {
-        Err(PyException::new_err(
+        return Err(QSharpError::new_err(
             "callable must be either a GlobalCallable or a Closure",
-        ))
+        ));
+    };
+
+    // Ensure the value is either a callabe with no functors or a closure with no functors
+    match &callable_val {
+        Value::Closure(closure) if closure.functor == FunctorApp::default() => {}
+        Value::Global(_, functor) if *functor == FunctorApp::default() => {}
+        Value::Closure(_) | Value::Global(_, _) => {
+            return Err(QSharpError::new_err(
+                "callable must have no applied functors (`Adjoint` or `Controlled`)",
+            ));
+        }
+        _ => {
+            return Err(QSharpError::new_err(
+                "callable must be either a GlobalCallable or a Closure",
+            ));
+        }
     }
+
+    Ok(callable_val)
 }
 
 #[pyfunction]

source/qdk_package/src/interpreter/data_interop.rs

@@ -4,7 +4,7 @@
 //! This module contains the types and functions used to build the
 //! data-interop layer between Python and Q#.
 
-use crate::interpreter::{Closure, GlobalCallable, QasmError};
+use crate::interpreter::{Closure, GlobalCallable, QSharpError, QasmError};
 
 use super::{Pauli, Result};
 use num_bigint::BigInt;
@@ -214,6 +214,71 @@ where
     }
 }
 
+/// Finds any Q# type recursively that does not support interop with Python, meaning our code cannot convert it back and forth
+/// across the interop boundary.
+pub(super) fn first_unsupported_interop_ty<'ctx, 'ty>(
+    ctx: &'ctx interpret::Interpreter,
+    ty: &'ty Ty,
+    allow_any_primitive: bool,
+) -> Option<String>
+where
+    'ty: 'ctx,
+{
+    match ty {
+        Ty::Prim(prim_ty) => match prim_ty {
+            Prim::Pauli
+            | Prim::BigInt
+            | Prim::Bool
+            | Prim::Double
+            | Prim::Int
+            | Prim::String
+            | Prim::Result => None,
+            Prim::Qubit | Prim::Range | Prim::RangeTo | Prim::RangeFrom | Prim::RangeFull => {
+                if allow_any_primitive {
+                    None
+                } else {
+                    Some(ty.to_string())
+                }
+            }
+        },
+        Ty::Tuple(tup) => tup
+            .iter()
+            .find_map(|t| first_unsupported_interop_ty(ctx, t, allow_any_primitive)),
+        Ty::Array(ty) => first_unsupported_interop_ty(ctx, ty, allow_any_primitive),
+        Ty::Udt(_, res) => {
+            let qsc::hir::Res::Item(item_id) = res else {
+                panic!("Udt should be an item");
+            };
+            let (udt, _) = ctx.udt_ty_from_item_id(item_id);
+
+            let Ok(fields) = collect_udt_fields(udt) else {
+                return Some(ty.to_string());
+            };
+
+            for field in fields {
+                if let Some(ty) = first_unsupported_interop_ty(ctx, field.1, allow_any_primitive) {
+                    return Some(ty);
+                }
+            }
+
+            None
+        }
+        Ty::Arrow(arrow) => {
+            // Reject unsupported types in the input and output of the callable, but allow any primitive types as those won't
+            // be coming from Python directly. Primarily this ends up rejecting callables with generic type parameters,
+            // to avoid having to infer concrete types on the fly.
+            if let Some(ty) = first_unsupported_interop_ty(ctx, &arrow.input.borrow(), true) {
+                return Some(ty);
+            }
+            if let Some(ty) = first_unsupported_interop_ty(ctx, &arrow.output.borrow(), true) {
+                return Some(ty);
+            }
+            None
+        }
+        Ty::Infer(..) | Ty::Param { .. } | Ty::Err => Some(ty.to_string()),
+    }
+}
+
 /// Given a type, convert a Python object into a Q# value of that type. This will recur through tuples and arrays,
 /// and will return an error if the type is not supported or the object cannot be converted.
 pub(super) fn pyobj_to_value(
@@ -273,10 +338,14 @@ pub(super) fn pyobj_to_value(
         Ty::Udt(_, res) => pyobj_to_udt(ctx, py, obj, ty, res),
         Ty::Arrow(..) => {
             if let Ok(callable) = extract_obj::<GlobalCallable>(py, obj, ty) {
-                return Ok(callable.into());
+                let callable_val = callable.into();
+                check_callable_types(ctx, &callable_val)?;
+                return Ok(callable_val);
             }
             if let Ok(callable) = extract_obj::<Closure>(py, obj, ty) {
-                return Ok(callable.into());
+                let callable_val = callable.into();
+                check_callable_types(ctx, &callable_val)?;
+                return Ok(callable_val);
             }
             Err(PyTypeError::new_err(format!(
                 "expected a callable, found {}",
@@ -287,6 +356,23 @@ pub(super) fn pyobj_to_value(
     }
 }
 
+fn check_callable_types(ctx: &interpret::Interpreter, callable_val: &Value) -> PyResult<()> {
+    let (input_ty, output_ty) = ctx
+        .global_callable_ty(callable_val)
+        .ok_or(QSharpError::new_err("callable not found"))?;
+    if let Some(ty) = first_unsupported_interop_ty(ctx, &input_ty, true) {
+        Err(QSharpError::new_err(format!(
+            "unsupported input type: `{ty}`"
+        )))
+    } else if let Some(ty) = first_unsupported_interop_ty(ctx, &output_ty, true) {
+        Err(QSharpError::new_err(format!(
+            "unsupported output type: `{ty}`"
+        )))
+    } else {
+        Ok(())
+    }
+}
+
 fn pyobj_to_udt(
     ctx: &interpret::Interpreter,
     py: Python,

source/qdk_package/tests/test_qsharp.py

@@ -918,6 +918,55 @@ def test_callable_with_unsupported_udt_return_type_raises_error_on_call() -> Non
         qdk.code.Unsupported()
 
 
+def test_callable_with_functor_raises_error_on_call() -> None:
+    qsharp.init()
+    callable = qsharp.eval("""
+        operation Unsupported() : Unit is Adj + Ctl { }
+        Adjoint Unsupported
+        """)
+    with pytest.raises(
+        qsharp.QSharpError,
+        match="callable must have no applied functors",
+    ):
+        qsharp.run(callable, shots=1)
+    callable = qsharp.eval("Controlled Unsupported")
+    with pytest.raises(
+        qsharp.QSharpError,
+        match="callable must have no applied functors",
+    ):
+        qsharp.run(callable, shots=1)
+
+
+def test_callable_with_generic_type_raises_error_on_call() -> None:
+    qsharp.init()
+    qsharp.eval("""
+        function Unsupported<'T>(a : 'T) : Unit { }
+        """)
+    with pytest.raises(qsharp.QSharpError, match="unsupported input type"):
+        qdk.code.Unsupported()
+
+
+def test_callable_with_function_argument_with_generic_type_raises_error_on_call() -> (
+    None
+):
+    qsharp.init()
+    qsharp.eval("""
+        function Unsupported<'T>(a : 'T -> 'T) : Unit { }
+        """)
+    with pytest.raises(qsharp.QSharpError, match="unsupported input type"):
+        qdk.code.Unsupported()
+
+
+def test_callable_with_generic_function_as_input_raises_error_on_call() -> None:
+    qsharp.init()
+    qsharp.eval("""
+        function Identity<'T>(x : 'T) : 'T { x }
+        function IntIdentity(x : Int, id : (Int -> Int)) : Int { id(x) }
+        """)
+    with pytest.raises(qsharp.QSharpError, match="unsupported input type"):
+        qdk.code.IntIdentity(42, qdk.code.Identity)
+
+
 def test_returning_unsupported_udt_from_eval_raises_error_on_call() -> None:
     qsharp.init()
     with pytest.raises(