update

Author: CppCXY

crates/luars/src/gc/gc_object.rs

@@ -267,7 +267,6 @@ impl GcHeader {
     pub fn is_marked(&self) -> bool {
         !self.is_white()
     }
-
 }
 
 pub struct Gc<T> {

crates/luars/src/gc/mod.rs

@@ -1040,7 +1040,9 @@ impl GC {
                 // Lua 5.5: GCScallfin calls pending finalizers from 'tobefnz'.
                 // We delegate the actual calls to the VM via pending_actions.
                 if !self.tobefnz.is_empty() {
-                    self.pending_actions.to_finalize.extend(self.tobefnz.drain(..));
+                    self.pending_actions
+                        .to_finalize
+                        .extend(self.tobefnz.drain(..));
                 }
                 self.gc_state = GcState::Pause;
                 StepResult::Pause
@@ -1187,6 +1189,52 @@ impl GC {
     /// CRITICAL: Only mark WHITE objects. Black objects from previous cycle became
     /// "other white" after color flip, so they WILL be marked again.
     /// Fixed objects (metamethod names) are kept GRAY forever, so they're naturally skipped.
+
+    /// Mark OLD1 objects for young collection (port of Lua 5.5's markold).
+    /// In generational mode, OLD1 objects are those that just became old in the
+    /// previous cycle. They need to be traversed because they might reference
+    /// young objects that need to be marked.
+    ///
+    /// Port of Lua 5.5 lgc.c:
+    /// ```c
+    /// static void markold (global_State *g, GCObject *from, GCObject *to) {
+    ///   GCObject *p;
+    ///   for (p = from; p != to; p = p->next) {
+    ///     if (getage(p) == G_OLD1) {
+    ///       lua_assert(!iswhite(p));
+    ///       setage(p, G_OLD);  /* now they are old */
+    ///       if (isblack(p))
+    ///         reallymarkobject(g, p);
+    ///     }
+    ///   }
+    /// }
+    /// ```
+    fn mark_old1(&mut self) {
+        // Iterate through all objects in gc_pool
+        // Find OLD1 objects and re-mark them if they're black
+        for i in 0..self.gc_pool.len() {
+            if let Some(owner) = self.gc_pool.get(i) {
+                let gc_ptr = owner.as_gc_ptr();
+                if let Some(header) = gc_ptr.header_mut() {
+                    if header.age() == G_OLD1 {
+                        // Assert: OLD1 objects should NOT be white
+                        debug_assert!(!header.is_white(), "OLD1 object should not be white");
+
+                        // Advance age to G_OLD
+                        header.set_age(G_OLD);
+
+                        // If it's black, re-mark it (add to gray list for traversal)
+                        if header.is_black() {
+                            // Make it gray and add to gray list
+                            header.make_gray();
+                            self.gray.push(gc_ptr);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     fn mark_value(&mut self, value: &LuaValue) {
         let Some(gc_ptr) = value.as_gc_ptr() else {
             return;
@@ -1821,9 +1869,15 @@ impl GC {
         let max_sweep = if fast { usize::MAX } else { 100 };
         let mut count = 0;
         let other_white = 1 - self.current_white;
+        let mut total_iterations = 0usize;
 
         // Sweep forward through pool, handling swap_remove correctly
         while self.sweep_index < self.gc_pool.len() && count < max_sweep {
+            total_iterations += 1;
+            if total_iterations > 10000 {
+                break;
+            }
+
             let current_idx = self.sweep_index;
 
             // Get object info
@@ -1832,8 +1886,7 @@ impl GC {
             let header = owner.header();
 
             debug_assert_eq!(
-                header.index,
-                current_idx,
+                header.index, current_idx,
                 "GcHeader.index mismatch during sweep (pool corrupted?)"
             );
 
@@ -1860,10 +1913,37 @@ impl GC {
                 // DON'T increment sweep_index - the object from end was moved here
                 // Next iteration will check that moved object
             } else {
-                // Lua 5.5 sweeplist: surviving objects reset to current white
+                // Surviving object - handle differently based on GC mode
                 if let Some(header_mut) = gc_ptr.header_mut() {
-                    header_mut.make_white(self.current_white);
-                    header_mut.set_age(G_NEW);
+                    if self.gc_kind == GcKind::Inc || self.gc_kind == GcKind::GenMajor {
+                        // INCREMENTAL MODE: Lua 5.5's sweeplist
+                        // All surviving objects go back to white + G_NEW
+                        // Port of: curr->marked = cast_byte((marked & ~maskgcbits) | white | G_NEW);
+                        header_mut.make_white(self.current_white);
+                        header_mut.set_age(G_NEW);
+                    } else {
+                        // GENERATIONAL MODE (GenMinor): Lua 5.5's sweepgen
+                        // Only G_NEW objects go back to white; older objects keep their color
+                        let age = header_mut.age();
+                        if age == G_NEW {
+                            // New objects go back to white and become G_SURVIVAL
+                            header_mut.make_white(self.current_white);
+                            header_mut.set_age(G_SURVIVAL);
+                        } else {
+                            // Older objects keep their color and advance age
+                            // Port of Lua 5.5's nextage table
+                            let next_age = match age {
+                                G_SURVIVAL => G_OLD1,
+                                G_OLD0 => G_OLD1,
+                                G_OLD1 => G_OLD,
+                                G_OLD => G_OLD,           // already old
+                                G_TOUCHED1 => G_TOUCHED1, // keep same
+                                G_TOUCHED2 => G_TOUCHED2, // keep same
+                                _ => G_OLD,
+                            };
+                            header_mut.set_age(next_age);
+                        }
+                    }
                 }
                 self.sweep_index += 1; // Move to next
             }
@@ -2091,6 +2171,12 @@ impl GC {
         self.restart_collection(roots);
         self.gc_state = GcState::Propagate;
 
+        // CRITICAL: Mark OLD1 objects before propagation!
+        // In generational mode, OLD1 objects are black from the previous cycle.
+        // They must be re-traversed so their referenced young objects get marked.
+        // Port of Lua 5.5's markold call in youngcollection.
+        self.mark_old1();
+
         // Propagate all marks
         while !self.gray.is_empty() {
             self.propagate_mark();

crates/luars/src/lua_value/lua_table/hash_table.rs

@@ -82,7 +82,7 @@ impl LuaTableImpl for LuaHashTable {
                 self.update_array_len_insert(k);
             }
         }
-        
+
         result
     }
 

crates/luars/src/lua_value/lua_value.rs

@@ -955,8 +955,19 @@ impl std::hash::Hash for LuaValue {
         } else if tt <= LUA_VFALSE {
             // nil or boolean - hash type tag only
             tt.hash(state);
+        } else if self.ttisstring() {
+            // CRITICAL: Strings must hash by CONTENT, not pointer!
+            // This maintains the Hash/Eq invariant: if a == b then hash(a) == hash(b)
+            // PartialEq compares string contents, so Hash must also use contents
+            tt.hash(state);
+            if let Some(s) = self.as_str() {
+                s.hash(state);
+            } else {
+                // Fallback: use pointer if we can't get the string content
+                self.raw_ptr_repr().hash(state);
+            }
         } else {
-            // GC types: hash type tag + gc_id
+            // Other GC types: hash type tag + pointer (they use identity for equality)
             tt.hash(state);
             self.raw_ptr_repr().hash(state);
         }

crates/luars/src/lua_vm/execute/mod.rs

@@ -1059,7 +1059,6 @@ pub fn lua_execute_until(lua_state: &mut LuaState, target_depth: usize) -> LuaRe
                     let a = instr.get_a() as usize;
                     let b = instr.get_b() as usize;
                     let c = instr.get_c() as usize;
-
                     // Save PC before call
                     save_pc!();
 
@@ -1454,6 +1453,7 @@ pub fn lua_execute_until(lua_state: &mut LuaState, target_depth: usize) -> LuaRe
                             lua_state.error(format!("GETTABUP: invalid upvalue index {}", b))
                         );
                     }
+
                     let table_value = upvalue_ptrs[b].as_ref().data.get_value(lua_state);
 
                     // Get key from constants (K[C])

crates/luars/src/lua_vm/mod.rs

@@ -549,11 +549,10 @@ impl LuaVM {
         // Collect roots
         let roots = self.collect_roots();
 
-        // CRITICAL: Mark open upvalues before entering atomic phase.
-        // In Lua, remarkupvals happens during atomic; we keep the same requirement
-        // by letting the VM push open upvalues into the GC marking frontier.
-        let open_upvals = self.main_state.get_open_upvalues();
-        self.gc.mark_open_upvalues(&open_upvals, &self.main_state);
+        // NOTE: mark_open_upvalues should NOT be called here!
+        // In Lua 5.5, remarkupvals is called DURING the atomic phase,
+        // after restart_collection. Calling it here would add objects
+        // to the gray list, which then gets cleared by restart_collection.
 
         // If we're keeping invariant (in marking phase), sweep first
         if self.gc.keep_invariant() {
@@ -587,9 +586,8 @@ impl LuaVM {
     fn full_gen(&mut self) {
         let roots = self.collect_roots();
 
-        // Same as incremental: ensure open upvalues are marked as part of the root set.
-        let open_upvals = self.main_state.get_open_upvalues();
-        self.gc.mark_open_upvalues(&open_upvals, &self.main_state);
+        // NOTE: mark_open_upvalues should NOT be called here!
+        // In Lua 5.5, remarkupvals is called DURING the atomic phase.
         self.gc.full_generation(&roots, &mut self.object_allocator);
     }
 

crates/luars/src/stdlib/basic/require.rs

@@ -72,7 +72,9 @@ pub fn lua_require(l: &mut LuaState) -> LuaResult<usize> {
     // Try each searcher (iterate until we hit nil)
     let mut i = 1;
     loop {
-        let searcher = searchers_table.raw_geti(i as i64).unwrap_or(LuaValue::nil());
+        let searcher = searchers_table
+            .raw_geti(i as i64)
+            .unwrap_or(LuaValue::nil());
 
         if searcher.is_nil() {
             break;