pytest: promote 'Explicitly requested dtype' UserWarning to an error

JAX silently truncates `jnp.int64` / `jnp.float64` requests under
`jax_enable_x64=False` and emits a `UserWarning`. The default test
config (`filterwarnings = []`) let those warnings pass — a stray
`int64` literal in src/ would slip through CI as a warning the
operator would have to spot by eye.

Switch the filter to `error:Explicitly requested dtype.*:UserWarning`.
Combined with the existing `--precision=32` job (`tests-32bit`),
every wide-dtype literal in src/ now fails the suite.

The three dtype-invariant test modules (`test_int_dtype_invariants`,
`test_float_dtype_invariants`, `test_dtypes`) opt back to the warning
default via a module-level `pytestmark` — they exist to *exercise* the
cast at the barrier and legitimately pass `int64` / `float64` inputs.

Add `tests/test_explicit_dtype_filter.py` with two tests confirming
the filter is in effect: each requests a wide dtype and asserts the
warning surfaces as `UserWarning`. Addresses the review on #340
without the false-positive surface of a literal-string grep.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hmgaudecker

pyproject.toml

@@ -245,6 +245,9 @@ per-file-ignores."tests/*" = [
 per-file-ignores."tests/test_dtypes.py" = [
   "ARG001", # Unused function argument (x64_enabled / x64_disabled fixtures)
 ]
+per-file-ignores."tests/test_explicit_dtype_filter.py" = [
+  "ARG001", # Unused function argument (x64_disabled fixture)
+]
 per-file-ignores."tests/test_float_dtype_invariants.py" = [
   "ARG001", # Unused function argument (x64_disabled fixture)
 ]
@@ -300,7 +303,15 @@ ini_options.addopts = [
   "--dist",
   "loadfile",
 ]
-ini_options.filterwarnings = []
+ini_options.filterwarnings = [
+  # JAX emits this UserWarning when user code asks for a dtype wider
+  # than the active x64 setting allows. Under `--precision=32` it
+  # surfaces every stray `jnp.int64` / `jnp.float64` / `dtype=int64`
+  # literal in src/ — the only files that legitimately trigger it are
+  # the dtype-invariant test modules, which opt out via a local
+  # `pytestmark` filter.
+  "error:Explicitly requested dtype.*:UserWarning",
+]
 ini_options.markers = [
   "illustrative: Tests are designed for illustrative purposes",
   "gpu: Tests that require a GPU (skipped on CPU-only machines)",

tests/test_dtypes.py

@@ -6,6 +6,14 @@
 
 from lcm.dtypes import canonical_float_dtype, safe_to_float_dtype, safe_to_int_dtype
 
+# Several tests here pass `int64` / `float64` inputs to verify the
+# barrier helpers cast them correctly. Re-allow the JAX truncation
+# warning that the project-wide filter (see `pyproject.toml`) promotes
+# to an error — the legitimate trigger lives here.
+pytestmark = pytest.mark.filterwarnings(
+    "default:Explicitly requested dtype.*:UserWarning"
+)
+
 
 @pytest.mark.parametrize(
     "value",

tests/test_explicit_dtype_filter.py

@@ -0,0 +1,23 @@
+"""Pyproject's `filterwarnings` rule promotes the JAX truncation warning to an error.
+
+The rule fires when source code asks for a dtype wider than the active
+`jax_enable_x64` setting permits — under `--precision=32`, every stray
+`jnp.int64` / `jnp.float64` request in `src/` becomes a test failure.
+The dtype-invariant test modules opt back to `default` for the same
+warning because they exist to *exercise* the cast at the barrier.
+"""
+
+import jax.numpy as jnp
+import pytest
+
+
+def test_float64_request_under_no_x64_raises(x64_disabled: None):
+    """A `jnp.float64` literal under `jax_enable_x64=False` is promoted to an error."""
+    with pytest.raises(UserWarning, match="Explicitly requested dtype float64"):
+        jnp.asarray([1.0, 2.0], dtype=jnp.float64)
+
+
+def test_int64_request_under_no_x64_raises(x64_disabled: None):
+    """A `jnp.int64` literal under `jax_enable_x64=False` is promoted to an error."""
+    with pytest.raises(UserWarning, match="Explicitly requested dtype int64"):
+        jnp.asarray([1, 2, 3], dtype=jnp.int64)

tests/test_float_dtype_invariants.py

@@ -19,6 +19,14 @@
     get_params,
 )
 
+# These tests deliberately pass `float64` inputs to verify the cast at
+# the barrier. Re-allow the JAX truncation warning that the
+# project-wide filter (see `pyproject.toml`) promotes to an error —
+# the legitimate trigger lives here.
+pytestmark = pytest.mark.filterwarnings(
+    "default:Explicitly requested dtype.*:UserWarning"
+)
+
 
 def test_build_initial_states_casts_user_float64_to_canonical(x64_disabled: None):
     """A float64 continuous initial state lands at `canonical_float_dtype()`."""

tests/test_int_dtype_invariants.py

@@ -25,6 +25,14 @@
     working_life,
 )
 
+# These tests deliberately pass `int64` inputs to verify the cast at
+# the barrier. Re-allow the JAX truncation warning that the
+# project-wide filter (see `pyproject.toml`) promotes to an error —
+# the legitimate trigger lives here.
+pytestmark = pytest.mark.filterwarnings(
+    "default:Explicitly requested dtype.*:UserWarning"
+)
+
 
 def test_discrete_grid_to_jax_is_int32() -> None:
     """Every `DiscreteGrid.to_jax()` in the model returns an `int32` array."""