Merge ARC branch into main

.github/copilot-instructions.md

@@ -0,0 +1,46 @@
+# Copilot instructions for this repository
+
+## Build and test commands
+
+```bash
+# Standard development build
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+
+# Run the CTest entry point wired in CMake
+cd build && ctest --output-on-failure
+cd build && ctest -R LuaTestSuite --output-on-failure
+
+# Run the end-to-end Lua compatibility suite in user mode
+cd testes && ../build/moon -e "_U=true" all.lua
+
+# Focused checks
+cd testes && ../build/moon phase0_smoke.mn   # quick interpreter smoke used by CI
+./build/test_arc                              # ARC reclamation regression test
+
+# Sanitizer build
+cmake -B build -DCMAKE_BUILD_TYPE=Debug -DLUA_ENABLE_ASAN=ON -DLUA_ENABLE_UBSAN=ON
+cmake --build build
+```
+
+There is no separate lint target. Normal CMake builds act as the lint gate because warnings are treated as errors (`-Werror`).
+
+`LUA_BUILD_TESTS` defaults to `ON` and injects `MOON_USER_H="mtests.h"` for the test harness. Use `-DLUA_BUILD_TESTS=OFF` only when you explicitly want a production-style build.
+
+## High-level architecture
+
+- `libmoon_static` is the main product built from the whole runtime; the `moon` executable in `src/interpreter/moon.cpp` is a thin CLI on top of it. `libmoon_shared` is optional.
+- `src/core/` owns runtime state and control flow: `moon_State`, `GlobalState`, `CallInfo`, API entry points, protected-call/error handling, and the `MoonStack` subsystem.
+- `src/vm/` contains the bytecode interpreter. VM behavior is centralized in the `VirtualMachine` class; older `moonV_*` wrapper-style entry points have been folded into methods there.
+- `src/compiler/` parses source and emits bytecode/prototypes; `src/serialization/` dumps and undumps that bytecode representation.
+- `src/objects/` defines the runtime object model (`Table`, `TString`, `Proto`, closures, userdata, etc.) on top of `GCObject` / `GCBase`.
+- `src/memory/` is the current memory-management pivot point. The moon fork has replaced the old tracing-GC direction with ARC-style reference counting and deterministic drain logic in `mgc.cpp`; `src/memory/gc/*.cpp` still contains graph-walking/finalization machinery and related invariants that ARC code reuses.
+- `testes/` is still largely the upstream Lua test suite. Those tests are mostly `.lua` files, while Moon modules default to `.mn`; `testes/all.lua` prepends `./?.lua` to `package.path` so legacy helper modules still load.
+
+## Key repository-specific conventions
+
+- This branch is a hard fork to **moon**. Prefer `moon*` names, `include/moon*.h`, the `moon` binary, and `.mn` as the default script/module extension. Some older docs and tests still mention `lua`; treat those as historical unless the current source/build files say otherwise.
+- ARC ownership rules are critical. When changing stack, table, upvalue, or API write paths, use the existing ownership helpers (`moonC_slotAssign`, `moonC_slotInit`, `MoonStack::setSlot`, `copySlot`, `pushSlot`, `releaseRange`, etc.) instead of raw slot writes unless the code is intentionally doing an ownership transfer.
+- Keep stack manipulation inside `MoonStack` and opcode behavior inside `VirtualMachine` when possible. This codebase has already consolidated those responsibilities; avoid reintroducing scattered helper logic or wrapper layers.
+- Be careful with GC/layout-sensitive types. `GCObject`-derived layouts are intentionally guarded, including the reserved header padding in `src/objects/mobject_core.h`; do not remove layout-preserving fields or asserts when refactoring object headers.
+- CI currently uses `testes/phase0_smoke.mn` as the fast smoke path, but deeper local validation for runtime work should include `test_arc` and usually `testes/all.lua`.

.github/workflows/ci.yml

@@ -1,18 +1,16 @@
-name: Moon CI (Phase 0)
-
-# Moon fork, Phase 0: the tracing GC is neutered (ARC arrives in Phase 1), so the
-# full Lua test suite cannot run yet — it would grow memory without bound. CI
-# builds on both compilers and runs the self-contained Phase 0 smoke instead.
+name: Moon CI
 
 on:
   push:
-    branches: [ moon, main ]
+    branches:
+      - '**'
   pull_request:
-    branches: [ moon, main ]
+    branches: [ main ]
+  workflow_dispatch:
 
 jobs:
   build-and-test:
-    name: Build & Smoke (${{ matrix.compiler }}, ${{ matrix.build-type }})
+    name: Build & Tests (${{ matrix.compiler }}, ${{ matrix.build-type }})
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -44,7 +42,57 @@ jobs:
     - name: Build
       run: cmake --build build
 
-    - name: Phase 0 smoke
+    - name: ARC regression
+      run: ./build/test_arc
+
+    - name: Lua test suite
+      working-directory: build
+      run: ctest -R LuaTestSuite --output-on-failure
+
+    - name: Interpreter smoke
+      working-directory: testes
+      run: |
+        ../build/moon phase0_smoke.mn 2>&1 | tee smoke.txt
+        grep -q "phase0 smoke OK" smoke.txt || exit 1
+
+  lto-smoke:
+    name: LTO Smoke (${{ matrix.compiler }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [gcc-13, clang-15]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake ninja-build
+        if [[ "${{ matrix.compiler }}" == "gcc-13" ]]; then
+          sudo apt-get install -y g++-13
+          echo "CC=gcc-13" >> $GITHUB_ENV
+          echo "CXX=g++-13" >> $GITHUB_ENV
+        else
+          sudo apt-get install -y clang-15
+          echo "CC=clang-15" >> $GITHUB_ENV
+          echo "CXX=clang++-15" >> $GITHUB_ENV
+        fi
+
+    - name: Configure with LTO
+      run: |
+        cmake -B build \
+          -DCMAKE_BUILD_TYPE=Release \
+          -DCMAKE_C_COMPILER=${{ env.CC }} \
+          -DCMAKE_CXX_COMPILER=${{ env.CXX }} \
+          -DLUA_ENABLE_LTO=ON \
+          -G Ninja
+
+    - name: Build
+      run: cmake --build build
+
+    - name: Interpreter smoke
       working-directory: testes
       run: |
         ../build/moon phase0_smoke.mn 2>&1 | tee smoke.txt
@@ -68,11 +116,15 @@ jobs:
           -DLUA_ENABLE_ASAN=ON -DLUA_ENABLE_UBSAN=ON
         cmake --build build
 
+    - name: Sanitizer ARC regression
+      run: |
+        ASAN_OPTIONS=detect_leaks=0:halt_on_error=1 \
+        UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
+        ./build/test_arc
+
     - name: Sanitizer smoke
       working-directory: testes
       run: |
-        # Phase 0 leaks by design (GC neutered), so disable leak detection;
-        # still catch use-after-free / out-of-bounds / UB on a bounded workload.
         ASAN_OPTIONS=detect_leaks=0:halt_on_error=1 \
         UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 \
         ../build/moon phase0_smoke.mn 2>&1 | tee smoke.txt
@@ -81,14 +133,16 @@ jobs:
   build-summary:
     name: Build Summary
     runs-on: ubuntu-latest
-    needs: [build-and-test, sanitizers]
+    needs: [build-and-test, lto-smoke, sanitizers]
     if: always()
     steps:
     - name: Check results
       run: |
         echo "Build & Smoke: ${{ needs.build-and-test.result }}"
+        echo "LTO Smoke:     ${{ needs.lto-smoke.result }}"
         echo "Sanitizers:    ${{ needs.sanitizers.result }}"
         if [[ "${{ needs.build-and-test.result }}" != "success" ]] || \
+           [[ "${{ needs.lto-smoke.result }}" != "success" ]] || \
            [[ "${{ needs.sanitizers.result }}" != "success" ]]; then
           echo "❌ Some checks failed"; exit 1
         fi

.github/workflows/coverage.yml

@@ -1,9 +1,7 @@
 name: Code Coverage
 
 on:
-  # Moon fork Phase 0: coverage runs the full Lua suite, which can't run under the
-  # neutered GC. Manual-only until the suite is restored with ARC (Phase 1+).
-  workflow_dispatch:  # Allow manual trigger
+  workflow_dispatch:
 
 jobs:
   coverage:
@@ -35,7 +33,7 @@ jobs:
 
     - name: Run tests to generate coverage data
       working-directory: testes
-      run: ../build/lua all.lua
+      run: ../build/moon -e "_U=true" all.lua
 
     - name: Generate coverage report
       run: |
@@ -110,12 +108,3 @@ jobs:
             repo: context.repo.repo,
             body: body
           });
-
-    # Optional: Upload to Codecov
-    # - name: Upload to Codecov
-    #   uses: codecov/codecov-action@v4
-    #   with:
-    #     files: ./coverage_filtered.info
-    #     flags: unittests
-    #     name: codecov-lua-cpp
-    #     fail_ci_if_error: false

.gitignore

@@ -17,6 +17,7 @@ temp
 build/
 build_clang/
 build-clang/
+build-asan/
 install_test/
 cmake-build-*/
 coverage_html/

CMakeLists.txt

@@ -19,7 +19,7 @@ option(LUA_ENABLE_ASSERTIONS "Enable runtime assertions (for debugging)" ON)
 option(LUA_ENABLE_ASAN "Enable AddressSanitizer" OFF)
 option(LUA_ENABLE_UBSAN "Enable UndefinedBehaviorSanitizer" OFF)
 option(LUA_ENABLE_COVERAGE "Enable code coverage reporting (gcov/lcov)" OFF)
-option(LUA_ENABLE_LTO "Enable Link Time Optimization" OFF)
+option(LUA_ENABLE_LTO "Enable Link Time Optimization for optimized builds" ON)
 option(LUA_BUILD_SHARED "Build shared library in addition to static" OFF)
 
 # Platform detection
@@ -126,14 +126,22 @@ endif()
 
 # Link Time Optimization
 if(LUA_ENABLE_LTO)
-    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_MINSIZEREL TRUE)
     # LTO can be aggressive about strict aliasing - Lua uses type punning extensively
     # so we need to disable strict aliasing optimization to ensure correctness
-    add_compile_options(-fno-strict-aliasing)
-    add_link_options(-fno-strict-aliasing)
+    add_compile_options(
+        "$<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>:-fno-strict-aliasing>"
+    )
+    add_link_options(
+        "$<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>:-fno-strict-aliasing>"
+    )
     if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
         # Fat LTO objects: GCC-only flag (clang rejects it, fatal under -Werror).
-        add_compile_options(-ffat-lto-objects)
+        add_compile_options(
+            "$<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>,$<CONFIG:MinSizeRel>>:-ffat-lto-objects>"
+        )
         # GCC 15's whole-program IPA miscompiles the GC liveness/marking path:
         # the registry root fails checkliveness on any full collection. clang+LTO
         # and UBSan are both clean, so this is a GCC LTO bug, not portable UB.
@@ -145,11 +153,8 @@ if(LUA_ENABLE_LTO)
         set_source_files_properties(
             src/memory/mgc.cpp
             src/memory/gc/gc_core.cpp
-            src/memory/gc/gc_marking.cpp
             src/memory/gc/gc_sweeping.cpp
             src/memory/gc/gc_finalizer.cpp
-            src/memory/gc/gc_weak.cpp
-            src/memory/gc/gc_collector.cpp
             PROPERTIES COMPILE_OPTIONS "-fno-lto")
     endif()
 endif()
@@ -194,11 +199,8 @@ set(LUA_MEMORY_SOURCES
     src/memory/mgc.cpp
     src/memory/mmem.cpp
     src/memory/gc/gc_core.cpp
-    src/memory/gc/gc_marking.cpp
     src/memory/gc/gc_sweeping.cpp
     src/memory/gc/gc_finalizer.cpp
-    src/memory/gc/gc_weak.cpp
-    src/memory/gc/gc_collector.cpp
 )
 
 set(LUA_SERIALIZATION_SOURCES
@@ -389,23 +391,23 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
         ${CMAKE_CURRENT_SOURCE_DIR}/src/vm
         ${CMAKE_CURRENT_SOURCE_DIR}/src/serialization
     )
-
-    # ARC reclamation engine test (moon fork, Phase 1)
-    add_executable(test_arc test_arc.cpp)
-    target_link_libraries(test_arc PRIVATE libmoon_static)
-    target_compile_options(test_arc PRIVATE -Wall ${WARNING_FLAGS} ${OPTIMIZE_FLAGS})
-    target_include_directories(test_arc PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/testing
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/memory
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/memory/gc
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/core
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/objects
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/compiler
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/vm
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/serialization
-    )
 endif()
 
+# ARC reclamation engine test (moon fork, Phase 1)
+add_executable(test_arc test_arc.cpp)
+target_link_libraries(test_arc PRIVATE libmoon_static)
+target_compile_options(test_arc PRIVATE -Wall ${WARNING_FLAGS} ${OPTIMIZE_FLAGS})
+target_include_directories(test_arc PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/testing
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/memory
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/memory/gc
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/core
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/objects
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/compiler
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/vm
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/serialization
+)
+
 # Install targets
 include(GNUInstallDirs)