co_consts

Author: youknowone

crates/codegen/src/compile.rs

@@ -3281,12 +3281,19 @@ impl Compiler {
         // Set qualname
         self.set_qualname();
 
-        // Handle docstring
+        // Handle docstring - store in co_consts[0] if present (CPython 3.14+)
         let (doc_str, body) = split_doc(body, &self.opts);
-        self.current_code_info()
-            .metadata
-            .consts
-            .insert_full(ConstantData::None);
+        if let Some(doc) = &doc_str {
+            // Docstring present: store in co_consts[0] and set HAS_DOCSTRING flag
+            self.current_code_info()
+                .metadata
+                .consts
+                .insert_full(ConstantData::Str {
+                    value: doc.to_string().into(),
+                });
+            self.current_code_info().flags |= bytecode::CodeFlags::HAS_DOCSTRING;
+        }
+        // If no docstring, don't add None to co_consts (CPython 3.14 behavior)
 
         // Compile body statements
         self.compile_statements(body)?;
@@ -3306,16 +3313,8 @@ impl Compiler {
         // Create function object with closure
         self.make_closure(code, funcflags)?;
 
-        // Handle docstring if present
-        if let Some(doc) = doc_str {
-            emit!(self, Instruction::Copy { index: 1_u32 });
-            self.emit_load_const(ConstantData::Str {
-                value: doc.to_string().into(),
-            });
-            emit!(self, Instruction::Swap { index: 2 });
-            let doc_attr = self.name("__doc__");
-            emit!(self, Instruction::StoreAttr { idx: doc_attr });
-        }
+        // Note: docstring is now retrieved from co_consts[0] by the VM
+        // when HAS_DOCSTRING flag is set, so no runtime __doc__ assignment needed
 
         Ok(())
     }
@@ -6166,10 +6165,7 @@ impl Compiler {
                     in_async_scope: false,
                 };
 
-                self.current_code_info()
-                    .metadata
-                    .consts
-                    .insert_full(ConstantData::None);
+                // Lambda cannot have docstrings, so no None is added to co_consts (CPython 3.14+)
 
                 self.compile_expression(body)?;
                 self.emit_return_value();

crates/compiler-core/src/bytecode.rs

@@ -389,13 +389,16 @@ pub struct CodeObject<C: Constant = ConstantData> {
 
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct CodeFlags: u16 {
+    pub struct CodeFlags: u32 {
         const OPTIMIZED = 0x0001;
         const NEWLOCALS = 0x0002;
         const VARARGS = 0x0004;
         const VARKEYWORDS = 0x0008;
         const GENERATOR = 0x0020;
         const COROUTINE = 0x0080;
+        /// If a code object represents a function and has a docstring,
+        /// this bit is set and the first item in co_consts is the docstring.
+        const HAS_DOCSTRING = 0x4000000;
     }
 }
 

crates/compiler-core/src/marshal.rs

@@ -202,7 +202,7 @@ pub fn deserialize_code<R: Read, Bag: ConstantBag>(
         })
         .collect::<Result<Box<[(SourceLocation, SourceLocation)]>>>()?;
 
-    let flags = CodeFlags::from_bits_truncate(rdr.read_u16()?);
+    let flags = CodeFlags::from_bits_truncate(rdr.read_u32()?);
 
     let posonlyarg_count = rdr.read_u32()?;
     let arg_count = rdr.read_u32()?;
@@ -660,7 +660,7 @@ pub fn serialize_code<W: Write, C: Constant>(buf: &mut W, code: &CodeObject<C>)
         buf.write_u32(end.character_offset.to_zero_indexed() as _);
     }
 
-    buf.write_u16(code.flags.bits());
+    buf.write_u32(code.flags.bits());
 
     buf.write_u32(code.posonlyarg_count);
     buf.write_u32(code.arg_count);

crates/vm/src/builtins/code.rs

@@ -152,7 +152,7 @@ pub struct ReplaceArgs {
     #[pyarg(named, optional)]
     co_names: OptionalArg<Vec<PyObjectRef>>,
     #[pyarg(named, optional)]
-    co_flags: OptionalArg<u16>,
+    co_flags: OptionalArg<u32>,
     #[pyarg(named, optional)]
     co_varnames: OptionalArg<Vec<PyObjectRef>>,
     #[pyarg(named, optional)]
@@ -177,6 +177,13 @@ pub struct ReplaceArgs {
 #[repr(transparent)]
 pub struct Literal(PyObjectRef);
 
+impl Literal {
+    /// Get a reference to the inner PyObjectRef
+    pub fn as_object(&self) -> &PyObjectRef {
+        &self.0
+    }
+}
+
 impl Borrow<PyObject> for Literal {
     fn borrow(&self) -> &PyObject {
         &self.0
@@ -411,7 +418,7 @@ pub struct PyCodeNewArgs {
     kwonlyargcount: u32,
     nlocals: u32,
     stacksize: u32,
-    flags: u16,
+    flags: u32,
     co_code: PyBytesRef,
     consts: PyTupleRef,
     names: PyTupleRef,
@@ -628,7 +635,7 @@ impl PyCode {
     }
 
     #[pygetset]
-    const fn co_flags(&self) -> u16 {
+    const fn co_flags(&self) -> u32 {
         self.code.flags.bits()
     }
 

crates/vm/src/builtins/function.rs

@@ -72,6 +72,17 @@ impl PyFunction {
             }
         });
 
+        // Get docstring from co_consts[0] if HAS_DOCSTRING flag is set (CPython 3.14+)
+        let doc = if code.code.flags.contains(bytecode::CodeFlags::HAS_DOCSTRING) {
+            code.code
+                .constants
+                .first()
+                .map(|c| c.as_object().clone())
+                .unwrap_or_else(|| vm.ctx.none())
+        } else {
+            vm.ctx.none()
+        };
+
         let qualname = vm.ctx.new_str(code.qualname.as_str());
         let func = Self {
             code: PyMutex::new(code.clone()),
@@ -85,7 +96,7 @@ impl PyFunction {
             annotations: PyMutex::new(None),
             annotate: PyMutex::new(None),
             module: PyMutex::new(module),
-            doc: PyMutex::new(vm.ctx.none()),
+            doc: PyMutex::new(doc),
             #[cfg(feature = "jit")]
             jitted_code: OnceCell::new(),
         };

crates/vm/src/builtins/object.rs

@@ -188,10 +188,7 @@ fn type_slot_names(typ: &Py<PyType>, vm: &VirtualMachine) -> PyResult<Option<sup
 fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine) -> PyResult {
     // Check itemsize - CPython lines 7260-7264
     if required && obj.class().slots.itemsize > 0 {
-        return Err(vm.new_type_error(format!(
-            "cannot pickle {:.200} objects",
-            obj.class().name()
-        )));
+        return Err(vm.new_type_error(format!("cannot pickle {:.200} objects", obj.class().name())));
     }
 
     let state = if obj.dict().is_none_or(|d| d.is_empty()) {
@@ -228,9 +225,7 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
 
         // Compare: if actual type's basicsize > expected basicsize, fail (CPython lines 7297-7304)
         if obj.class().slots.basicsize > basicsize {
-            return Err(
-                vm.new_type_error(format!("cannot pickle '{}' object", obj.class().name()))
-            );
+            return Err(vm.new_type_error(format!("cannot pickle '{}' object", obj.class().name())));
         }
     }
 
@@ -675,9 +670,7 @@ fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     // Check if type has tp_new
     let cls = obj.class();
     if cls.slots.new.load().is_none() {
-        return Err(
-            vm.new_type_error(format!("cannot pickle '{}' object", cls.name()))
-        );
+        return Err(vm.new_type_error(format!("cannot pickle '{}' object", cls.name())));
     }
 
     let (args, kwargs) = get_new_arguments(&obj, vm)?;
@@ -686,13 +679,13 @@ fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
 
     let has_args = args.is_some();
 
-    let (newobj, newargs): (PyObjectRef, PyObjectRef) = if kwargs.is_none() || kwargs.as_ref().is_some_and(|k| k.is_empty()) {
+    let (newobj, newargs): (PyObjectRef, PyObjectRef) = if kwargs.is_none()
+        || kwargs.as_ref().is_some_and(|k| k.is_empty())
+    {
         // Use copyreg.__newobj__
         let newobj = copyreg.get_attr("__newobj__", vm)?;
 
-        let args_vec: Vec<PyObjectRef> = args
-            .map(|a| a.as_slice().to_vec())
-            .unwrap_or_default();
+        let args_vec: Vec<PyObjectRef> = args.map(|a| a.as_slice().to_vec()).unwrap_or_default();
 
         // Create (cls, *args) tuple
         let mut newargs_vec: Vec<PyObjectRef> = vec![cls.to_owned().into()];
@@ -703,10 +696,16 @@ fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     } else {
         // Use copyreg.__newobj_ex__
         let newobj = copyreg.get_attr("__newobj_ex__", vm)?;
-        let args_tuple: PyObjectRef = args.map(|a| a.into()).unwrap_or_else(|| vm.ctx.empty_tuple.clone().into());
-        let kwargs_dict: PyObjectRef = kwargs.map(|k| k.into()).unwrap_or_else(|| vm.ctx.new_dict().into());
-
-        let newargs = vm.ctx.new_tuple(vec![cls.to_owned().into(), args_tuple, kwargs_dict]);
+        let args_tuple: PyObjectRef = args
+            .map(|a| a.into())
+            .unwrap_or_else(|| vm.ctx.empty_tuple.clone().into());
+        let kwargs_dict: PyObjectRef = kwargs
+            .map(|k| k.into())
+            .unwrap_or_else(|| vm.ctx.new_dict().into());
+
+        let newargs = vm
+            .ctx
+            .new_tuple(vec![cls.to_owned().into(), args_tuple, kwargs_dict]);
         (newobj, newargs.into())
     };
 
@@ -720,7 +719,9 @@ fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
 
     let (listitems, dictitems) = get_items_iter(&obj, vm)?;
 
-    let result = vm.ctx.new_tuple(vec![newobj, newargs, state, listitems, dictitems]);
+    let result = vm
+        .ctx
+        .new_tuple(vec![newobj, newargs, state, listitems, dictitems]);
     Ok(result.into())
 }
 

extra_tests/snippets/code_co_consts.py

@@ -1,39 +1,108 @@
+"""
+Test co_consts behavior for Python 3.14+
+
+In Python 3.14+:
+- Functions with docstrings have the docstring as co_consts[0]
+- CO_HAS_DOCSTRING flag (0x4000000) indicates docstring presence
+- Functions without docstrings do NOT have None added as placeholder for docstring
+
+Note: Other constants (small integers, code objects, etc.) may still appear in co_consts
+depending on optimization level. This test focuses on docstring behavior.
+"""
+
+
+# Test function with docstring - docstring should be co_consts[0]
+def with_doc():
+    """This is a docstring"""
+    return 1
+
+
+assert with_doc.__code__.co_consts[0] == "This is a docstring", with_doc.__code__.co_consts
+assert with_doc.__doc__ == "This is a docstring"
+# Check CO_HAS_DOCSTRING flag (0x4000000)
+assert with_doc.__code__.co_flags & 0x4000000, hex(with_doc.__code__.co_flags)
+
+
+# Test function without docstring - should NOT have HAS_DOCSTRING flag
+def no_doc():
+    return 1
+
+
+assert not (no_doc.__code__.co_flags & 0x4000000), hex(no_doc.__code__.co_flags)
+assert no_doc.__doc__ is None
+
+
+# Test async function with docstring
 from asyncio import sleep
 
 
-def f():
-    def g():
-        return 1
+async def async_with_doc():
+    """Async docstring"""
+    await sleep(1)
+    return 1
 
-    assert g.__code__.co_consts[0] == None
-    return 2
 
+assert async_with_doc.__code__.co_consts[0] == "Async docstring", async_with_doc.__code__.co_consts
+assert async_with_doc.__doc__ == "Async docstring"
+assert async_with_doc.__code__.co_flags & 0x4000000
 
-assert f.__code__.co_consts[0] == None
 
+# Test async function without docstring
+async def async_no_doc():
+    await sleep(1)
+    return 1
+
+
+assert not (async_no_doc.__code__.co_flags & 0x4000000)
+assert async_no_doc.__doc__ is None
 
-def generator():
+
+# Test generator with docstring
+def gen_with_doc():
+    """Generator docstring"""
     yield 1
     yield 2
 
 
-assert generator().gi_code.co_consts[0] == None
+assert gen_with_doc.__code__.co_consts[0] == "Generator docstring"
+assert gen_with_doc.__doc__ == "Generator docstring"
+assert gen_with_doc.__code__.co_flags & 0x4000000
 
 
-async def async_f():
-    await sleep(1)
-    return 1
+# Test generator without docstring
+def gen_no_doc():
+    yield 1
+    yield 2
+
 
+assert not (gen_no_doc.__code__.co_flags & 0x4000000)
+assert gen_no_doc.__doc__ is None
 
-assert async_f.__code__.co_consts[0] == None
 
+# Test lambda - cannot have docstring
 lambda_f = lambda: 0
-assert lambda_f.__code__.co_consts[0] == None
+assert not (lambda_f.__code__.co_flags & 0x4000000)
+assert lambda_f.__doc__ is None
+
+
+# Test class method with docstring
+class cls_with_doc:
+    def method():
+        """Method docstring"""
+        return 1
+
 
+assert cls_with_doc.method.__code__.co_consts[0] == "Method docstring"
+assert cls_with_doc.method.__doc__ == "Method docstring"
 
-class cls:
-    def f():
+
+# Test class method without docstring
+class cls_no_doc:
+    def method():
         return 1
 
 
-assert cls().f.__code__.co_consts[0] == None
+assert not (cls_no_doc.method.__code__.co_flags & 0x4000000)
+assert cls_no_doc.method.__doc__ is None
+
+print("All co_consts tests passed!")