downlevel pep 696 type-param defaults on 3.12 targets, hard error for reified

Author: KotlinIsland

crates/by_transforms/src/transforms/generics.rs

@@ -125,6 +125,19 @@ impl<'src> GenericPolyfill<'src> {
         }
     }
 
+    /// whether the target can keep this parameter list as native syntax:
+    /// pep 695 lists need 3.12+, and a pep 696 default (`[T = int]`) bumps
+    /// the requirement to 3.13. a defaulted list on a 3.12 target polyfills
+    /// the declaration exactly like pre-3.12 code
+    fn supports_native_type_params(&self, params: &[TypeParam]) -> bool {
+        let required = if params.iter().any(|p| p.default().is_some()) {
+            PythonVersion::PY313
+        } else {
+            PythonVersion::PY312
+        };
+        self.config.min_version >= required
+    }
+
     /// Pick a unique mangled name for a `TypeVar`.
     ///
     /// First emission of a given source name returns the standard mangled
@@ -439,8 +452,8 @@ impl<'src> GenericPolyfill<'src> {
             self.parameters_targets
                 .insert(class.name.id.as_str().to_owned());
         }
-        // PEP 695 class type params are native syntax in 3.12+
-        if self.config.min_version >= PythonVersion::PY312 {
+        // PEP 695 class type params are native syntax in 3.12+ (3.13+ with defaults)
+        if self.supports_native_type_params(&tp.type_params) {
             self.strip_constraints_keyword(&tp.type_params);
             return;
         }
@@ -533,8 +546,8 @@ impl<'src> GenericPolyfill<'src> {
             self.parameters_targets
                 .insert(func.name.id.as_str().to_owned());
         }
-        // PEP 695 function type params are native syntax in 3.12+
-        if self.config.min_version >= PythonVersion::PY312 {
+        // PEP 695 function type params are native syntax in 3.12+ (3.13+ with defaults)
+        if self.supports_native_type_params(&tp.type_params) {
             self.strip_constraints_keyword(&tp.type_params);
             return;
         }
@@ -587,7 +600,11 @@ impl<'src> GenericPolyfill<'src> {
     fn process_type_alias(&mut self, alias: &StmtTypeAlias) {
         // `type Point = tuple[float, float]`
         //   → `Point = TypeAliasType("Point", tuple[float, float])`
-        if self.config.min_version >= PythonVersion::PY312 {
+        let params = alias
+            .type_params
+            .as_deref()
+            .map_or(&[][..], |tp| tp.type_params.as_slice());
+        if self.supports_native_type_params(params) {
             if let Some(tp) = &alias.type_params {
                 self.strip_constraints_keyword(&tp.type_params);
             }
@@ -1308,6 +1325,132 @@ mod tests {
         check_at(src, expected, PythonVersion::PY314);
     }
 
+    #[test]
+    fn function_default_downleveled_on_312() {
+        // pep 696 defaults are 3.13-only syntax: a defaulted list on a 3.12
+        // target polyfills like pre-3.12 code instead of passing through
+        check_at(
+            indoc! {"
+                def f[T = int](x: T) -> T:
+                    return x
+            "},
+            indoc! {"
+                from typing_extensions import TypeVar
+                _T = TypeVar(\"_T\", default=int)
+                def f(x: _T) -> _T:
+                    return x
+            "},
+            PythonVersion::PY312,
+        );
+    }
+
+    #[test]
+    fn function_default_unchanged_on_313() {
+        let src = indoc! {"
+            def f[T = int](x: T) -> T:
+                return x
+        "};
+        check_at(src, src, PythonVersion::PY313);
+        check_at(src, src, PythonVersion::PY314);
+    }
+
+    #[test]
+    fn class_default_downleveled_on_312() {
+        check_at(
+            "class A[T = int]: ...\n",
+            indoc! {"
+                from typing import Generic
+                from typing_extensions import TypeVar
+                _T = TypeVar(\"_T\", default=int)
+                class A(Generic[_T]): ...
+            "},
+            PythonVersion::PY312,
+        );
+    }
+
+    #[test]
+    fn class_bound_and_default_downleveled_on_312() {
+        // the bound rides along into the polyfilled call next to the default
+        check_at(
+            "class A[T: int = int]: ...\n",
+            indoc! {"
+                from typing import Generic
+                from typing_extensions import TypeVar
+                _T = TypeVar(\"_T\", bound=int, default=int)
+                class A(Generic[_T]): ...
+            "},
+            PythonVersion::PY312,
+        );
+    }
+
+    #[test]
+    fn class_default_unchanged_on_313() {
+        let src = "class A[T = int]: ...\n";
+        check_at(src, src, PythonVersion::PY313);
+        check_at(src, src, PythonVersion::PY314);
+    }
+
+    #[test]
+    fn only_defaulted_declarations_downlevel_on_312() {
+        // gating is per declaration: the defaulted class polyfills while the
+        // plain one keeps native pep 695 syntax
+        check_at(
+            indoc! {"
+                class A[T = int]: ...
+                class B[T]: ...
+            "},
+            indoc! {"
+                from typing import Generic
+                from typing_extensions import TypeVar
+                _T = TypeVar(\"_T\", default=int)
+                class A(Generic[_T]): ...
+                class B[T]: ...
+            "},
+            PythonVersion::PY312,
+        );
+    }
+
+    #[test]
+    fn paramspec_and_typevartuple_defaults_downlevel_on_312() {
+        // defaults on any parameter kind make the header 3.13-only syntax, so
+        // the whole declaration polyfills. the polyfill itself drops paramspec
+        // and typevartuple defaults, matching the pre-3.12 path
+        check_at(
+            indoc! {"
+                class A[**P = [int]]: ...
+                class B[*Ts = *tuple[int, str]]: ...
+            "},
+            indoc! {"
+                from typing import TypeVarTuple, Unpack, ParamSpec, Generic
+                _P = ParamSpec(\"_P\")
+                class A(Generic[_P]): ...
+                _Ts = TypeVarTuple(\"_Ts\")
+                class B(Generic[*_Ts]): ...
+            "},
+            PythonVersion::PY312,
+        );
+    }
+
+    #[test]
+    fn type_alias_default_downleveled_on_312() {
+        check_at(
+            "type Vector[T = int] = list[T]\n",
+            indoc! {"
+                from typing_extensions import TypeVar, TypeAliasType
+                _T = TypeVar(\"_T\", default=int)
+                Vector = TypeAliasType(\"Vector\", list[_T], type_params=(_T,))
+            "},
+            PythonVersion::PY312,
+        );
+    }
+
+    #[test]
+    fn type_alias_default_unchanged_on_313() {
+        let src = "type Vector[T = int] = list[T]\n";
+        check_at(src, src, PythonVersion::PY313);
+        check_at(src, src, PythonVersion::PY314);
+    }
+
     #[test]
     fn variance_covariant_polyfill() {
         check(

crates/by_transforms/src/transforms/intersection.rs

@@ -69,8 +69,12 @@ mod tests {
     }
 
     fn check_py312(input: &str, expected: &str) {
+        check_at(input, expected, PythonVersion::PY312);
+    }
+
+    fn check_at(input: &str, expected: &str, version: PythonVersion) {
         let config = Config {
-            min_version: PythonVersion::PY312,
+            min_version: version,
             ..Config::test_default()
         };
         assert_eq!(
@@ -201,12 +205,29 @@ mod tests {
 
     #[test]
     fn intersection_in_typeparam_default() {
-        check_py312(
+        // native passthrough of a defaulted list needs 3.13 (pep 696)
+        check_at(
             "def f[T = A & B](x: T) -> T: ...\n",
             indoc! {"
                 from ty_extensions import Intersection
                 def f[T = Intersection[A, B]](x: T) -> T: ...
             "},
+            PythonVersion::PY313,
+        );
+    }
+
+    #[test]
+    fn intersection_in_typeparam_default_downlevels_on_312() {
+        // on a 3.12 target the defaulted list polyfills, and the intersection
+        // still lowers inside the `default=` argument
+        check_py312(
+            "def f[T = A & B](x: T) -> T: ...\n",
+            indoc! {"
+                from ty_extensions import Intersection
+                from typing_extensions import TypeVar
+                _T = TypeVar(\"_T\", default=Intersection[A, B])
+                def f(x: _T) -> _T: ...
+            "},
         );
     }
 

crates/by_transforms/src/transforms/not_type.rs

@@ -16,8 +16,12 @@ mod tests {
     }
 
     fn check_py312(input: &str, expected: &str) {
+        check_at(input, expected, PythonVersion::PY312);
+    }
+
+    fn check_at(input: &str, expected: &str, version: PythonVersion) {
         let config = Config {
-            min_version: PythonVersion::PY312,
+            min_version: version,
             ..Config::test_default()
         };
         assert_eq!(
@@ -122,12 +126,29 @@ mod tests {
 
     #[test]
     fn not_in_typeparam_default() {
-        check_py312(
+        // native passthrough of a defaulted list needs 3.13 (pep 696)
+        check_at(
             "def f[T = not int](x: T) -> T: ...\n",
             indoc! {"
                 from ty_extensions import Not
                 def f[T = Not[int]](x: T) -> T: ...
             "},
+            PythonVersion::PY313,
+        );
+    }
+
+    #[test]
+    fn not_in_typeparam_default_downlevels_on_312() {
+        // on a 3.12 target the defaulted list polyfills, and the negation
+        // still lowers inside the `default=` argument
+        check_py312(
+            "def f[T = not int](x: T) -> T: ...\n",
+            indoc! {"
+                from ty_extensions import Not
+                from typing_extensions import TypeVar
+                _T = TypeVar(\"_T\", default=Not[int])
+                def f(x: _T) -> _T: ...
+            "},
         );
     }
 

crates/by_transforms/src/transforms/reified_generic.rs

@@ -30,6 +30,10 @@
 //! lowered `def` must keep its native `[T]` syntax. that is only available on
 //! python 3.12+, so reification is gated on `min_version >= 3.12`; below that
 //! the pass reports a hard error rather than emit code that cannot run.
+//! pep 696 defaults (`[T = int]`) raise the bar to 3.13 — they are not valid
+//! syntax on 3.12, and the erased polyfill can't stand in because it discards
+//! the native parameter list reification depends on — so a reified function
+//! with a defaulted parameter on a 3.12 target is a hard error too
 
 use ruff_python_ast::visitor::{Visitor, walk_stmt};
 use ruff_python_ast::{PythonVersion, Stmt, StmtFunctionDef};
@@ -100,7 +104,10 @@ struct ReifiedGeneric<'src> {
     used: bool,
     /// a reified function was found but the target is below 3.12
     below_312: Vec<String>,
+    /// a reified function has a pep 696 default but the target is below 3.13
+    defaulted_below_313: Vec<String>,
     supports_native_generics: bool,
+    supports_param_defaults: bool,
 }
 
 impl<'src> ReifiedGeneric<'src> {
@@ -110,7 +117,9 @@ impl<'src> ReifiedGeneric<'src> {
             edits: Vec::new(),
             used: false,
             below_312: Vec::new(),
+            defaulted_below_313: Vec::new(),
             supports_native_generics: min_version >= PythonVersion::PY312,
+            supports_param_defaults: min_version >= PythonVersion::PY313,
         }
     }
 
@@ -122,6 +131,17 @@ impl<'src> ReifiedGeneric<'src> {
             self.below_312.push(function.name.id.to_string());
             return;
         }
+        // any default in the list makes the native header 3.13-only syntax,
+        // even on parameters that don't themselves reify
+        if !self.supports_param_defaults
+            && function
+                .type_params
+                .as_deref()
+                .is_some_and(|tp| tp.type_params.iter().any(|p| p.default().is_some()))
+        {
+            self.defaulted_below_313.push(function.name.id.to_string());
+            return;
+        }
         // the decorator goes on its own line directly above the `def`, sharing
         // its indentation. the first decorator's range start (or the `def`
         // keyword when undecorated) is the insertion point
@@ -175,6 +195,15 @@ impl TypeAwarePass for ReifiedGenericPass<'_> {
             ));
             return;
         }
+        if let Some(name) = inner.defaulted_below_313.first() {
+            ctx.errors.push(format!(
+                "reified generic function `{name}` has a type-parameter default, \
+                 which requires python 3.13 or newer: reification keeps the native \
+                 pep 695 parameter list in the generated python, and pep 696 \
+                 defaults are not valid syntax before 3.13"
+            ));
+            return;
+        }
         if inner.used {
             ctx.required_imports
                 .push("from dataclasses import dataclass".to_owned());
@@ -337,6 +366,51 @@ mod tests {
         );
     }
 
+    #[test]
+    fn default_on_312_is_an_error() {
+        // pep 696 defaults are 3.13-only syntax, and a reified function can't
+        // fall back to the erased polyfill, so 3.12 targets get a hard error
+        let err = transpile(
+            indoc! {"
+                def f[T = int]():
+                    print(T)
+            "},
+            &Config {
+                min_version: PythonVersion::PY312,
+                ..Config::test_default()
+            },
+        )
+        .unwrap_err();
+        assert!(
+            err.contains("3.13"),
+            "expected a 3.13 requirement error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn default_on_313_wraps_natively() {
+        let out = transpile(
+            indoc! {"
+                def f[T = int]():
+                    print(T)
+                f()
+            "},
+            &Config {
+                min_version: PythonVersion::PY313,
+                ..Config::test_default()
+            },
+        )
+        .unwrap();
+        assert!(
+            out.contains("@generic  # basedpython: reified"),
+            "should wrap: {out}"
+        );
+        assert!(
+            out.contains("def f[T = int]():"),
+            "native defaulted params kept: {out}"
+        );
+    }
+
     #[test]
     fn non_generic_function_untouched() {
         unchanged("def f(x):\n    return x\n");