typing.NoDefault

youknowone · youknowone · commit 0c31c5ffbc68 · 2025-06-25T01:10:17.000+09:00
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
@@ -9706,14 +9706,14 @@ class CustomerModel(ModelBase, init=False):
 
 
 class NoDefaultTests(BaseTestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             s = pickle.dumps(NoDefault, proto)
             loaded = pickle.loads(s)
             self.assertIs(NoDefault, loaded)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_constructor(self):
         self.assertIs(NoDefault, type(NoDefault)())
         with self.assertRaises(TypeError):
@@ -9731,8 +9731,6 @@ def test_doc(self):
     def test_class(self):
         self.assertIs(NoDefault.__class__, type(NoDefault))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_no_call(self):
         with self.assertRaises(TypeError):
             NoDefault()
diff --git a/vm/src/stdlib/typing.rs b/vm/src/stdlib/typing.rs
@@ -1,4 +1,14 @@
-pub(crate) use _typing::make_module;
+use crate::{PyRef, VirtualMachine, stdlib::PyModule};
+
+pub(crate) use _typing::NoDefault;
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = _typing::make_module(vm);
+    extend_module!(vm, &module, {
+        "NoDefault" => vm.ctx.typing_no_default.clone(),
+    });
+    module
+}
 
 #[pymodule]
 pub(crate) mod _typing {
@@ -117,7 +127,7 @@ pub(crate) mod _typing {
                 Ok(default_value.clone())
             } else {
                 // Return NoDefault singleton
-                vm.import("typing", 0)?.get_attr("NoDefault", vm)
+                Ok(vm.ctx.typing_no_default.clone().into())
             }
         }
 
@@ -146,12 +156,7 @@ pub(crate) mod _typing {
                 return false;
             }
             // Check if default_value is NoDefault
-            if let Ok(typing_module) = vm.import("typing", 0) {
-                if let Ok(no_default) = typing_module.get_attr("NoDefault", vm) {
-                    return !default_value.is(&no_default);
-                }
-            }
-            true
+            !default_value.is(&vm.ctx.typing_no_default)
         }
     }
 
@@ -408,10 +413,9 @@ pub(crate) mod _typing {
         }
     }
 
-    #[pyattr]
-    #[pyclass(name = "NoDefault", module = "typing")]
+    #[pyclass(no_attr, name = "NoDefaultType", module = "typing")]
     #[derive(Debug, PyPayload)]
-    pub(crate) struct NoDefault;
+    pub struct NoDefault;
 
     #[pyclass(with(Constructor), flags(BASETYPE))]
     impl NoDefault {
@@ -429,8 +433,8 @@ pub(crate) mod _typing {
                 return Err(vm.new_type_error("NoDefaultType takes no arguments".to_owned()));
             }
 
-            // Return singleton instance
-            vm.import("typing", 0)?.get_attr("NoDefault", vm)
+            // Return singleton instance from context
+            Ok(vm.ctx.typing_no_default.clone().into())
         }
     }
 
diff --git a/vm/src/types/zoo.rs b/vm/src/types/zoo.rs
@@ -88,6 +88,7 @@ pub struct TypeZoo {
     pub object_type: &'static Py<PyType>,
     pub ellipsis_type: &'static Py<PyType>,
     pub none_type: &'static Py<PyType>,
+    pub typing_no_default_type: &'static Py<PyType>,
     pub not_implemented_type: &'static Py<PyType>,
     pub generic_alias_type: &'static Py<PyType>,
     pub union_type: &'static Py<PyType>,
@@ -179,6 +180,7 @@ impl TypeZoo {
             weakproxy_type: weakproxy::PyWeakProxy::init_builtin_type(),
             method_descriptor_type: descriptor::PyMethodDescriptor::init_builtin_type(),
             none_type: singletons::PyNone::init_builtin_type(),
+            typing_no_default_type: crate::stdlib::typing::NoDefault::init_builtin_type(),
             not_implemented_type: singletons::PyNotImplemented::init_builtin_type(),
             generic_alias_type: genericalias::PyGenericAlias::init_builtin_type(),
             union_type: union_::PyUnion::init_builtin_type(),
diff --git a/vm/src/vm/context.rs b/vm/src/vm/context.rs
@@ -41,6 +41,8 @@ pub struct Context {
     pub ellipsis: PyRef<PyEllipsis>,
     pub not_implemented: PyRef<PyNotImplemented>,
 
+    pub typing_no_default: PyRef<crate::stdlib::typing::NoDefault>,
+
     pub types: TypeZoo,
     pub exceptions: exceptions::ExceptionZoo,
     pub int_cache_pool: Vec<PyIntRef>,
@@ -278,6 +280,11 @@ impl Context {
         let ellipsis = create_object(PyEllipsis, PyEllipsis::static_type());
         let not_implemented = create_object(PyNotImplemented, PyNotImplemented::static_type());
 
+        let typing_no_default = create_object(
+            crate::stdlib::typing::NoDefault,
+            crate::stdlib::typing::NoDefault::static_type(),
+        );
+
         let int_cache_pool = Self::INT_CACHE_POOL_RANGE
             .map(|v| {
                 PyRef::new_ref(
@@ -317,6 +324,7 @@ impl Context {
             true_value,
             false_value,
             none,
+            typing_no_default,
             empty_tuple,
             empty_frozenset,
             empty_str,

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,14 @@`
`1`		`-pub(crate) use _typing::make_module;`
	`1`	`+use crate::{PyRef, VirtualMachine, stdlib::PyModule};`
	`2`	`+`
	`3`	`+pub(crate) use _typing::NoDefault;`
	`4`	`+`
	`5`	`+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {`
	`6`	`+ let module = _typing::make_module(vm);`
	`7`	`+ extend_module!(vm, &module, {`
	`8`	`+ "NoDefault" => vm.ctx.typing_no_default.clone(),`
	`9`	`+ });`
	`10`	`+ module`
	`11`	`+}`
`2`	`12`
`3`	`13`	`#[pymodule]`
`4`	`14`	`pub(crate) mod _typing {`
`@@ -117,7 +127,7 @@ pub(crate) mod _typing {`
`117`	`127`	`Ok(default_value.clone())`
`118`	`128`	`} else {`
`119`	`129`	`// Return NoDefault singleton`
`120`		`- vm.import("typing", 0)?.get_attr("NoDefault", vm)`
	`130`	`+ Ok(vm.ctx.typing_no_default.clone().into())`
`121`	`131`	`}`
`122`	`132`	`}`
`123`	`133`
`@@ -146,12 +156,7 @@ pub(crate) mod _typing {`
`146`	`156`	`return false;`
`147`	`157`	`}`
`148`	`158`	`// Check if default_value is NoDefault`
`149`		`- if let Ok(typing_module) = vm.import("typing", 0) {`
`150`		`- if let Ok(no_default) = typing_module.get_attr("NoDefault", vm) {`
`151`		`- return !default_value.is(&no_default);`
`152`		`- }`
`153`		`- }`
`154`		`- true`
	`159`	`+ !default_value.is(&vm.ctx.typing_no_default)`
`155`	`160`	`}`
`156`	`161`	`}`
`157`	`162`
`@@ -408,10 +413,9 @@ pub(crate) mod _typing {`
`408`	`413`	`}`
`409`	`414`	`}`
`410`	`415`
`411`		`- #[pyattr]`
`412`		`- #[pyclass(name = "NoDefault", module = "typing")]`
	`416`	`+ #[pyclass(no_attr, name = "NoDefaultType", module = "typing")]`
`413`	`417`	`#[derive(Debug, PyPayload)]`
`414`		`- pub(crate) struct NoDefault;`
	`418`	`+ pub struct NoDefault;`
`415`	`419`
`416`	`420`	`#[pyclass(with(Constructor), flags(BASETYPE))]`
`417`	`421`	`impl NoDefault {`
`@@ -429,8 +433,8 @@ pub(crate) mod _typing {`
`429`	`433`	`return Err(vm.new_type_error("NoDefaultType takes no arguments".to_owned()));`
`430`	`434`	`}`
`431`	`435`
`432`		`- // Return singleton instance`
`433`		`- vm.import("typing", 0)?.get_attr("NoDefault", vm)`
	`436`	`+ // Return singleton instance from context`
	`437`	`+ Ok(vm.ctx.typing_no_default.clone().into())`
`434`	`438`	`}`
`435`	`439`	`}`
`436`	`440`