Add ConstantData::Frozenset variant (type only, folding deferred)

Add Frozenset to ConstantData, BorrowedConstant, and marshal support. Actual frozenset folding (BUILD_SET + CONTAINS_OP → LOAD_CONST frozenset) requires VirtualMachine for element hashing and is deferred.
RustPython · youknowone · Mar 30, 2026 · Mar 29, 2026 · Mar 30, 2026 · Mar 30, 2026
commit f8927e11225c10453dbba486c38ead4ed15bbc2e
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
@@ -293,6 +293,7 @@ impl Constant for ConstantData {
             Self::Code { code } => Code { code },
             Self::Tuple { elements } => Tuple { elements },
             Self::Slice { elements } => Slice { elements },
+            Self::Frozenset { elements } => Frozenset { elements },
             Self::None => None,
             Self::Ellipsis => Ellipsis,
         }
@@ -860,6 +861,7 @@ pub enum ConstantData {
     Code { code: Box<CodeObject> },
     /// Constant slice(start, stop, step)
     Slice { elements: Box<[ConstantData; 3]> },
+    Frozenset { elements: Vec<ConstantData> },
     None,
     Ellipsis,
 }
@@ -882,6 +884,7 @@ impl PartialEq for ConstantData {
             (Code { code: a }, Code { code: b }) => core::ptr::eq(a.as_ref(), b.as_ref()),
             (Tuple { elements: a }, Tuple { elements: b }) => a == b,
             (Slice { elements: a }, Slice { elements: b }) => a == b,
+            (Frozenset { elements: a }, Frozenset { elements: b }) => a == b,
             (None, None) => true,
             (Ellipsis, Ellipsis) => true,
             _ => false,
@@ -909,6 +912,7 @@ impl hash::Hash for ConstantData {
             Code { code } => core::ptr::hash(code.as_ref(), state),
             Tuple { elements } => elements.hash(state),
             Slice { elements } => elements.hash(state),
+            Frozenset { elements } => elements.hash(state),
             None => {}
             Ellipsis => {}
         }
@@ -926,6 +930,7 @@ pub enum BorrowedConstant<'a, C: Constant> {
     Code { code: &'a CodeObject<C> },
     Tuple { elements: &'a [C] },
     Slice { elements: &'a [C; 3] },
+    Frozenset { elements: &'a [C] },
     None,
     Ellipsis,
 }
@@ -972,6 +977,19 @@ impl<C: Constant> BorrowedConstant<'_, C> {
                 elements[2].borrow_constant().fmt_display(f)?;
                 write!(f, ")")
             }
+            BorrowedConstant::Frozenset { elements } => {
+                write!(f, "frozenset({{")?;
+                let mut first = true;
+                for c in *elements {
+                    if first {
+                        first = false
+                    } else {
+                        write!(f, ", ")?;
+                    }
+                    c.borrow_constant().fmt_display(f)?;
+                }
+                write!(f, "}})")
+            }
             BorrowedConstant::None => write!(f, "None"),
             BorrowedConstant::Ellipsis => write!(f, "..."),
         }
@@ -1005,6 +1023,12 @@ impl<C: Constant> BorrowedConstant<'_, C> {
             BorrowedConstant::Slice { elements } => Slice {
                 elements: Box::new(elements.each_ref().map(|c| c.borrow_constant().to_owned())),
             },
+            BorrowedConstant::Frozenset { elements } => Frozenset {
+                elements: elements
+                    .iter()
+                    .map(|c| c.borrow_constant().to_owned())
+                    .collect(),
+            },
             BorrowedConstant::None => None,
             BorrowedConstant::Ellipsis => Ellipsis,
         }

diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
@@ -464,8 +464,9 @@ impl<Bag: ConstantBag> MarshalBag for Bag {
         Err(MarshalError::BadType)
     }
 
-    fn make_frozenset(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
-        Err(MarshalError::BadType)
+    fn make_frozenset(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
+        let elements: Vec<Self::Value> = it.collect();
+        Ok(self.make_constant::<Bag::Constant>(BorrowedConstant::Frozenset { elements: &elements }))
     }
 
     fn make_dict(
@@ -710,6 +711,7 @@ impl<'a, C: Constant> From<BorrowedConstant<'a, C>> for DumpableValue<'a, C> {
             BorrowedConstant::Slice { elements } => {
                 Self::Slice(&elements[0], &elements[1], &elements[2])
             }
+            BorrowedConstant::Frozenset { elements } => Self::Frozenset(elements),
             BorrowedConstant::None => Self::None,
             BorrowedConstant::Ellipsis => Self::Ellipsis,
         }

diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
@@ -242,6 +242,13 @@ fn borrow_obj_constant(obj: &PyObject) -> BorrowedConstant<'_, Literal> {
             let arr = Box::leak(Box::new([Literal(start), Literal(stop), Literal(step)]));
             BorrowedConstant::Slice { elements: arr }
         }
+        ref fs @ super::set::PyFrozenSet => {
+            // Box::leak the elements so they outlive the borrow. Leak is acceptable since
+            // constant pool objects live for the program's lifetime.
+            let elems: Vec<Literal> = fs.elements().into_iter().map(Literal).collect();
+            let elements = Box::leak(elems.into_boxed_slice());
+            BorrowedConstant::Frozenset { elements }
+        }
         _ => panic!("unexpected payload for constant python value"),
     })
 }
@@ -309,6 +316,14 @@ impl ConstantBag for PyObjBag<'_> {
                 .into_ref(ctx)
                 .into()
             }
+            BorrowedConstant::Frozenset { elements: _ } => {
+                // Creating a frozenset requires VirtualMachine for element hashing.
+                // PyObjBag only has Context, so we cannot construct PyFrozenSet here.
+                // Frozenset constants from .pyc are handled by PyMarshalBag which has VM access.
+                unimplemented!(
+                    "frozenset constant in PyObjBag::make_constant requires VirtualMachine"
+                )
+            }
             BorrowedConstant::None => ctx.none(),
             BorrowedConstant::Ellipsis => ctx.ellipsis.clone().into(),
         };