pre-commit: fix prettier formatting in doc/guides/capi.md

Co-authored-by: Claude <noreply@anthropic.com>
2026-06-08 16:11:16 +00:00 · 2026-03-12 13:09:44 +09:00
45 changed files with 3046 additions and 3335 deletions
@@ -5,27 +5,11 @@ updates:
    directory: "/"
    schedule:
      interval: "daily"
-    groups:
-      bundler-dependencies:
-        patterns:
-          - "*"
    cooldown:
      default-days: 7
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "daily"
-    groups:
-      github-actions-dependencies:
-        patterns:
-          - "*"
    cooldown:
      default-days: 7
-  - package-ecosystem: "pre-commit"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    groups:
-      pre-commit-hooks:
-        patterns:
-          - "*"
@@ -32,8 +32,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Compiler version
@@ -47,8 +45,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Cache cosmocc
@@ -75,8 +71,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Build and test
@@ -19,8 +19,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Initialize CodeQL
        uses: github/codeql-action/init@v4
        with:
@@ -2,9 +2,6 @@ name: Coverage

 on: [push]

-permissions:
-  contents: read
-
 jobs:
  coverage:
    name: Coverage
@@ -20,8 +17,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Ruby version
        run: ruby -v
      - name: Compiler version
@@ -12,8 +12,6 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - uses: ls-lint/action@v2.3.1
        with:
          config: .github/linters/.ls-lint.yml
@@ -1,22 +0,0 @@
-# https://github.com/j178/prek
-name: Manual hooks
-
-on: [pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  pre-commit:
-    name: Run pre-commit
-    runs-on: ubuntu-latest
-    steps:
-      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
-        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-      - uses: j178/prek-action@v2
-        with:
-          install-only: true
-      - name: Run manual pre-commit hooks
-        run: prek run --color=always --all-files --hook-stage manual
@@ -13,8 +13,8 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-      - uses: j178/prek-action@v2
+      - uses: j178/prek-action@v1
        with:
          extra-args: --all-files
+      - name: Run manual pre-commit hooks
+        run: prek run --color=always --all-files --hook-stage manual
@@ -20,8 +20,6 @@ jobs:
    steps:
      - name: "Checkout ${{ github.ref_name }} ( ${{ github.sha }} )"
        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
      - name: Builds
        id: builds
        run: |
@@ -19,7 +19,6 @@ jobs:
        with:
          # Full git history is needed to get a proper list of changed files within `super-linter`
          fetch-depth: 0
-          persist-credentials: false
      - name: Lint Code Base
        uses: super-linter/super-linter/slim@v8.5.0
        env:
@@ -3,7 +3,7 @@
 default_stages: [pre-commit, pre-push]
 default_language_version:
  python: python3
-  node: 24.14.0
+  node: 24.11.1
 minimum_pre_commit_version: "3.2.0"
 exclude: "^tools/lrama/"
 repos:
@@ -24,7 +24,6 @@ repos:
        files: \.(md|ya?ml)$
        language: node
        additional_dependencies: ["prettier@3.7.4"]
-        pass_filenames: false
        stages: [manual]
      - id: check-zip-file-is-not-committed
        name: disallow zip files
@@ -35,13 +34,13 @@ repos:
          track and have security implications. Please remove the zip file from the repository.
        files: \.zip$
  - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.30.1
+    rev: v8.30.0
    hooks:
      - id: gitleaks
        name: run gitleaks
        description: detect hardcoded secrets with gitleaks
  - repo: https://github.com/oxipng/oxipng
-    rev: v10.1.0
+    rev: v10.0.0
    hooks:
      - id: oxipng
        name: run oxipng
@@ -73,7 +72,7 @@ repos:
      - id: mixed-line-ending
      - id: trailing-whitespace
  - repo: https://github.com/Lucas-C/pre-commit-hooks
-    rev: v1.5.6
+    rev: v1.5.5
    hooks:
      - id: forbid-tabs
        name: run no-tabs checker
@@ -85,19 +84,19 @@ repos:
        args: [--whitespaces-count, "2"]
        exclude: Makefile$
  - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.11
+    rev: v1.7.9
    hooks:
      - id: actionlint
        name: run actionlint
        description: lint GitHub Actions workflow files
  - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.1
    hooks:
      - id: codespell
        name: run codespell
        description: check spelling with codespell
  - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.48.0
+    rev: v0.46.0
    hooks:
      - id: markdownlint
        name: run markdownlint
@@ -106,7 +105,7 @@ repos:
        types: [markdown]
        files: \.md$
  - repo: https://github.com/rubocop/rubocop
-    rev: v1.86.0
+    rev: v1.81.7
    hooks:
      - id: rubocop
        name: run rubocop
@@ -120,7 +119,7 @@ repos:
        name: run shellcheck
        description: check shell scripts with a static analysis tool
  - repo: https://github.com/adrienverge/yamllint
-    rev: v1.38.0
+    rev: v1.37.1
    hooks:
      - id: yamllint
        name: run yamllint
@@ -3,4 +3,3 @@ build
 coverage
 doc/internal/opcode.md
 tools/lrama
-.venv
@@ -23,8 +23,6 @@ mruby now supports pattern matching (case/in) syntax:
 - Trailing comma in method definition parameters: `def foo(a, b,)` ([f78334b](https://github.com/mruby/mruby/commit/f78334b))
 - Array/Hash/String subclasses can now override `[]` and `[]=` methods ([#6675](https://github.com/mruby/mruby/pull/6675))
 - `OP_SETIDX` optimization for Array and Hash ([ddd8fe1](https://github.com/mruby/mruby/commit/ddd8fe1))
- `case`/`in` without `else` now raises `NoMatchingPatternError` ([d8de35b](https://github.com/mruby/mruby/commit/d8de35b))
- Allow compound statement in parenthesized argument context ([919cbd8](https://github.com/mruby/mruby/commit/919cbd8))

 # Changes in C API

@@ -39,8 +37,6 @@ mruby now supports pattern matching (case/in) syntax:
 - `mrb_open()` returns mrb_state with exc set on init failure ([05ffe0c](https://github.com/mruby/mruby/commit/05ffe0c))
 - `mrb_utf8_to_buf()` for UTF-8 encoding consolidation ([7e28e68](https://github.com/mruby/mruby/commit/7e28e68))
 - `kh_is_end()` macro for safe khash iteration ([893cc75](https://github.com/mruby/mruby/commit/893cc75))
- `mrb_bigint_p()` always defined regardless of bigint gem presence ([6c4a8c0](https://github.com/mruby/mruby/commit/6c4a8c0))
- `RInteger` and `RFloat` added to `RVALUE` union ([13dbca0](https://github.com/mruby/mruby/commit/13dbca0))

 # ROM Method Tables

@@ -80,7 +76,6 @@ mruby-symbol-ext, mruby-range-ext, mruby-object-ext.
 - Emscripten: use native WASM exception handling ([ca364e3](https://github.com/mruby/mruby/commit/ca364e3))
 - HAL (Hardware Abstraction Layer) for platform abstraction in mruby-io, mruby-socket, mruby-dir, mruby-task ([74ca22f](https://github.com/mruby/mruby/commit/74ca22f))
 - `MRUBY_MIRB_READLINE` environment variable to control readline library selection ([0aafb83](https://github.com/mruby/mruby/commit/0aafb83))
- MSYS2 drive letter support in build script ([77f6ffe](https://github.com/mruby/mruby/commit/77f6ffe))
 - Inter-gem headers separated from external API headers ([#6671](https://github.com/mruby/mruby/pull/6671))

 # Changes in mrbgems
@@ -115,7 +110,6 @@ mruby-symbol-ext, mruby-range-ext, mruby-object-ext.
 ## Other Gem Changes

 - **_NOTE_**: `Hash#deconstruct_keys` removed for CRuby compatibility ([34b9412](https://github.com/mruby/mruby/commit/34b9412))
- **mruby-enum-lazy**: Fix `Lazy#flat_map` to handle non-enumerable block return values ([#6765](https://github.com/mruby/mruby/pull/6765))
 - **mruby-array-ext**: Add `Array#find` and `Array#rfind` methods
 - **mruby-io**: Add `IO#putc` and `Kernel#putc` ([baff6e6](https://github.com/mruby/mruby/commit/baff6e6))
 - **mruby-random**: Replace xoshiro with PCG for better memory efficiency ([f1bab01](https://github.com/mruby/mruby/commit/f1bab01))
@@ -131,8 +125,6 @@ mruby-symbol-ext, mruby-range-ext, mruby-object-ext.
 - Optimized masgn to generate literals directly into target registers ([fb5d966](https://github.com/mruby/mruby/commit/fb5d966))
 - Optimized splat of literal arrays in args/literals ([1cb8d73](https://github.com/mruby/mruby/commit/1cb8d73))
 - Early termination after too many parse errors ([510ebd7](https://github.com/mruby/mruby/commit/510ebd7))
- Chunk array literals at 64 elements to reduce register pressure ([f98d641](https://github.com/mruby/mruby/commit/f98d641))
- Chunk `%w()` and `%i()` literals to reduce register pressure ([62cf0dc](https://github.com/mruby/mruby/commit/62cf0dc))

 # VM Optimizations

@@ -193,10 +185,6 @@ Other optimizations:
 - [#6705](https://github.com/mruby/mruby/issues/6705) Can't get outer class of an object in C
 - [#6713](https://github.com/mruby/mruby/issues/6713) mruby-polarssl not work
 - [#6720](https://github.com/mruby/mruby/issues/6720) Random float range: different behavior from CRuby
- [#6722](https://github.com/mruby/mruby/issues/6722) RBreak size overflow on 32-bit platforms with MRB_NO_BOXING
- [#6740](https://github.com/mruby/mruby/issues/6740) `%w()`/`%i()` register pressure with large literals
- [#6741](https://github.com/mruby/mruby/issues/6741) `case`/`in` without `else` should raise `NoMatchingPatternError`
- [#6760](https://github.com/mruby/mruby/issues/6760) `mrb_gc_unregister()` not removing all matching entries

 # Merged Pull Requests

@@ -272,7 +260,6 @@ Other optimizations:
 - [#6589](https://github.com/mruby/mruby/pull/6589) Add pre-commit hook `check-zip-file-is-not-committed`
 - [#6591](https://github.com/mruby/mruby/pull/6591) mruby-eval fix license link in README
 - [#6593](https://github.com/mruby/mruby/pull/6593) README: Add Contributors Avatars, Star History, Table of Contents
- [#6598](https://github.com/mruby/mruby/pull/6598) Fix heap buffer overflow in `#method_missing`
 - [#6599](https://github.com/mruby/mruby/pull/6599) pre-commit: run `markdown-link-check`, `oxipng`, `prettier` manually
 - [#6600](https://github.com/mruby/mruby/pull/6600) `dreamcast_shelf build config`: update to use KallistiOS wrappers
 - [#6601](https://github.com/mruby/mruby/pull/6601) fix: skip local build_config.rb when working in MRUBY_ROOT
@@ -316,30 +303,6 @@ Other optimizations:
 - [#6716](https://github.com/mruby/mruby/pull/6716) Fixes identity for proc object
 - [#6717](https://github.com/mruby/mruby/pull/6717) Fix mruby-task: wrapping by critical section and setting initial task receiver
 - [#6718](https://github.com/mruby/mruby/pull/6718) Add installation instructions for conda and Homebrew
- [#6723](https://github.com/mruby/mruby/pull/6723) Add `RInteger` and `RFloat` to `RVALUE`
- [#6727](https://github.com/mruby/mruby/pull/6727) Language documentation: update wording of "overloading" section
- [#6729](https://github.com/mruby/mruby/pull/6729) Simplifying dependency addition for gensym task
- [#6730](https://github.com/mruby/mruby/pull/6730) Simplifying presym file generation actions
- [#6733](https://github.com/mruby/mruby/pull/6733) Include `mruby/presym.h` for all source files
- [#6734](https://github.com/mruby/mruby/pull/6734) Chunk array literals at 64 elements to reduce register pressure
- [#6735](https://github.com/mruby/mruby/pull/6735) Prevent full recompilation without changes to presym file
- [#6739](https://github.com/mruby/mruby/pull/6739) Fix MSYS2 build error with drive letters
- [#6743](https://github.com/mruby/mruby/pull/6743) Chunk `%w()` and `%i()` literals to reduce register pressure
- [#6744](https://github.com/mruby/mruby/pull/6744) Raise `NoMatchingPatternError` in `case`/`in` without `else`
- [#6747](https://github.com/mruby/mruby/pull/6747) Correctly handle empty hash as default named argument
- [#6749](https://github.com/mruby/mruby/pull/6749) Fix microcontroller profile
- [#6750](https://github.com/mruby/mruby/pull/6750) Fix out-of-bounds read and divide-by-zero in `Array#product`
- [#6752](https://github.com/mruby/mruby/pull/6752) Fix `attr_reader`-generated methods accepting extra arguments
- [#6753](https://github.com/mruby/mruby/pull/6753) Further optimize `Array#product`
- [#6754](https://github.com/mruby/mruby/pull/6754) Mark `attr_reader` procs as noarg
- [#6755](https://github.com/mruby/mruby/pull/6755) Reload `ci` after `mrb_hash_delete_key()` in keyword argument handling
- [#6756](https://github.com/mruby/mruby/pull/6756) Avoid impact of object modifications caused by `mrb_vm_exec()` calls
- [#6758](https://github.com/mruby/mruby/pull/6758) Don't assign result of `mrb_funcall()` directly to `regs`
- [#6759](https://github.com/mruby/mruby/pull/6759) Define `mrb_bigint_p()` always
- [#6761](https://github.com/mruby/mruby/pull/6761) Fix `mrb_gc_unregister()` to remove all matching entries
- [#6762](https://github.com/mruby/mruby/pull/6762) Write generated test C files atomically to avoid build race condition
- [#6765](https://github.com/mruby/mruby/pull/6765) Fix `Lazy#flat_map` to handle non-enumerable block return values
- [#6767](https://github.com/mruby/mruby/pull/6767) Allow compound statement in parenthesized argument context

 # Security Fixes

@@ -357,6 +320,4 @@ Other optimizations:
 - Heap-use-after-free in insertion_sort ([099d2c47](https://github.com/mruby/mruby/commit/099d2c47))
 - Integer overflow in str_check_length ([6afff1c3](https://github.com/mruby/mruby/commit/6afff1c3))
 - Integer overflow in Integer#lcm ([070bef24](https://github.com/mruby/mruby/commit/070bef24))
- Heap buffer overflow in `#method_missing` ([550d10a](https://github.com/mruby/mruby/commit/550d10a))
- Out-of-bounds read and divide-by-zero in `Array#product` ([8441eaf](https://github.com/mruby/mruby/commit/8441eaf))
 - Multiple memory leak fixes in bigint, Set, Array, and Task gems
@@ -30,7 +30,7 @@ MRuby::CrossBuild.new("ArduinoDue") do |conf|

    #configuration for low memory environment
    cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
    cc.defines << %w(MRB_GC_STRESS)
    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
    #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
@@ -16,7 +16,7 @@ MRuby::CrossBuild.new("RX630") do |conf|
    #configuration for low memory environment
    cc.defines << %w(MRB_USE_FLOAT32)
    cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
    cc.defines << %w(MRB_GC_STRESS)
    cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
    #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
@@ -27,7 +27,7 @@ MRuby::CrossBuild.new("chipKITMax32") do |conf|

    #configuration for low memory environment
    cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
-    cc.defines << %w(KHASH_INITIAL_SIZE=8)
+    cc.defines << %w(KHASH_DEFAULT_SIZE=8)
    cc.defines << %w(MRB_GC_STRESS)
    #cc.defines << %w(MRB_NO_STDIO) #if you don't need stdio.
    #cc.defines << %w(POOL_PAGE_SIZE=1000) #effective only for use with mruby-eval
@@ -4,44 +4,44 @@

 New to mruby? Start here:

-| Document                                     | Description                            |
-| -------------------------------------------- | -------------------------------------- |
+| Document | Description |
+| -------- | ----------- |
 | [Getting Started](guides/getting-started.md) | Build mruby and run your first program |
-| [Language Features](guides/language.md)      | Ruby subset supported by mruby         |
-| [Limitations](limitations.md)                | Behavioral differences from CRuby      |
+| [Language Features](guides/language.md) | Ruby subset supported by mruby |
+| [Limitations](limitations.md) | Behavioral differences from CRuby |

 ## Guides (for embedders and gem authors)

 ### Embedding mruby in C

-| Document                                | Description                                      |
-| --------------------------------------- | ------------------------------------------------ |
-| [C API Reference](guides/capi.md)       | Values, classes, methods, error handling, fibers |
-| [GC Arena](guides/gc-arena-howto.md)    | Managing temporary objects in C extensions       |
-| [Linking](guides/link.md)               | Linking with `libmruby`                          |
-| [Amalgamation](guides/amalgamation.md)  | Single-file build for easy integration           |
-| [Precompiled Symbols](guides/symbol.md) | Compile-time symbol allocation                   |
+| Document | Description |
+| -------- | ----------- |
+| [C API Reference](guides/capi.md) | Values, classes, methods, error handling, fibers |
+| [GC Arena](guides/gc-arena-howto.md) | Managing temporary objects in C extensions |
+| [Linking](guides/link.md) | Linking with `libmruby` |
+| [Amalgamation](guides/amalgamation.md) | Single-file build for easy integration |
+| [Precompiled Symbols](guides/symbol.md) | Compile-time symbol allocation |

 ### Building and Configuring

-| Document                                 | Description                                 |
-| ---------------------------------------- | ------------------------------------------- |
-| [Compilation](guides/compile.md)         | Build system, cross-compilation, toolchains |
-| [Build Configuration](guides/mrbconf.md) | Compile-time macros (`MRB_*` flags)         |
-| [mrbgems](guides/mrbgems.md)             | Creating and managing gems                  |
-| [Memory](guides/memory.md)               | Allocator customization and heap regions    |
+| Document | Description |
+| -------- | ----------- |
+| [Compilation](guides/compile.md) | Build system, cross-compilation, toolchains |
+| [Build Configuration](guides/mrbconf.md) | Compile-time macros (`MRB_*` flags) |
+| [mrbgems](guides/mrbgems.md) | Creating and managing gems |
+| [Memory](guides/memory.md) | Allocator customization and heap regions |

 ### Tools

-| Document                                        | Description                                     |
-| ----------------------------------------------- | ----------------------------------------------- |
-| [Debugger](guides/debugger.md)                  | Using `mrdb` for debugging                      |
+| Document | Description |
+| -------- | ----------- |
+| [Debugger](guides/debugger.md) | Using `mrdb` for debugging |
 | [ROM Method Tables](guides/rom-method-table.md) | Read-only method tables for constrained devices |

 ### Reference

-| Document                              | Description        |
-| ------------------------------------- | ------------------ |
+| Document | Description |
+| -------- | ----------- |
 | [Directory Structure](guides/hier.md) | Source tree layout |

 ## Internals (for mruby contributors)
@@ -49,14 +49,14 @@ New to mruby? Start here:
 Start with [Architecture](internal/architecture.md) for an overview,
 then dive into the subsystem you need:

-| Document                                  | Description                                        |
-| ----------------------------------------- | -------------------------------------------------- |
-| [Architecture](internal/architecture.md)  | Overview of object model, VM, GC, compiler         |
-| [Virtual Machine](internal/vm.md)         | Dispatch loop, call frames, method lookup, fibers  |
-| [Garbage Collector](internal/gc.md)       | Tri-color marking, write barriers, generational GC |
-| [Compiler Pipeline](internal/compiler.md) | Parser, code generator, IRep, binary format        |
-| [Opcodes](internal/opcode.md)             | VM instruction set reference                       |
-| [Value Boxing](internal/boxing.md)        | How `mrb_value` encodes types                      |
+| Document | Description |
+| -------- | ----------- |
+| [Architecture](internal/architecture.md) | Overview of object model, VM, GC, compiler |
+| [Virtual Machine](internal/vm.md) | Dispatch loop, call frames, method lookup, fibers |
+| [Garbage Collector](internal/gc.md) | Tri-color marking, write barriers, generational GC |
+| [Compiler Pipeline](internal/compiler.md) | Parser, code generator, IRep, binary format |
+| [Opcodes](internal/opcode.md) | VM instruction set reference |
+| [Value Boxing](internal/boxing.md) | How `mrb_value` encodes types |

 ## Release Notes

@@ -205,11 +205,11 @@ mruby's numeric type sizes depend on the boxing mode and platform.

 ### Integer

-| Configuration                          | Range            |
-| -------------------------------------- | ---------------- |
+| Configuration | Range |
+| ------------- | ----- |
 | 64-bit word boxing (default on 64-bit) | roughly +/- 2^62 |
 | 32-bit word boxing (default on 32-bit) | roughly +/- 2^30 |
-| NaN boxing (64-bit only)               | -2^31 to 2^31-1  |
+| NaN boxing (64-bit only) | -2^31 to 2^31-1 |

 Integer overflow raises a `RangeError` unless the `mruby-bigint` gem
 is included, in which case integers automatically promote to
@@ -235,32 +235,32 @@ With word boxing on 64-bit, many float values are stored inline

 These classes are always available in mruby (no gem required):

-| Class         | Notes                                  |
-| ------------- | -------------------------------------- |
-| Object        | Base class for all objects             |
-| Module        | Module definition and mixin            |
-| Class         | Class definition and instantiation     |
-| NilClass      | Singleton `nil`                        |
-| TrueClass     | Singleton `true`                       |
-| FalseClass    | Singleton `false`                      |
-| Integer       | Fixed-precision integer                |
-| Float         | Floating-point (unless `MRB_NO_FLOAT`) |
-| Symbol        | Interned identifier                    |
-| String        | Mutable byte string                    |
-| Array         | Ordered collection                     |
-| Hash          | Key-value mapping                      |
-| Range         | Interval representation                |
-| Proc          | Closure / callable object              |
-| Exception     | Exception hierarchy root               |
-| StandardError | Common error base                      |
+| Class | Notes |
+| ----- | ----- |
+| Object | Base class for all objects |
+| Module | Module definition and mixin |
+| Class | Class definition and instantiation |
+| NilClass | Singleton `nil` |
+| TrueClass | Singleton `true` |
+| FalseClass | Singleton `false` |
+| Integer | Fixed-precision integer |
+| Float | Floating-point (unless `MRB_NO_FLOAT`) |
+| Symbol | Interned identifier |
+| String | Mutable byte string |
+| Array | Ordered collection |
+| Hash | Key-value mapping |
+| Range | Interval representation |
+| Proc | Closure / callable object |
+| Exception | Exception hierarchy root |
+| StandardError | Common error base |

 ### Core Modules

-| Module     | Notes                                     |
-| ---------- | ----------------------------------------- |
-| Kernel     | Core methods (`puts`, `p`, `raise`, etc.) |
-| Comparable | Comparison operators via `<=>`            |
-| Enumerable | Collection iteration methods              |
+| Module | Notes |
+| ------ | ----- |
+| Kernel | Core methods (`puts`, `p`, `raise`, etc.) |
+| Comparable | Comparison operators via `<=>` |
+| Enumerable | Collection iteration methods |

 ## Standard Library (via gemboxes)

@@ -270,70 +270,70 @@ gembox provides the class or feature you need:

 ### Classes and Modules

-| Class/Module          | Gembox     | Gem               |
-| --------------------- | ---------- | ----------------- |
-| Fiber                 | stdlib     | mruby-fiber       |
-| Enumerator            | stdlib     | mruby-enumerator  |
-| Enumerator::Lazy      | stdlib     | mruby-enum-lazy   |
-| Set                   | stdlib     | mruby-set         |
-| ObjectSpace           | stdlib     | mruby-objectspace |
-| Time                  | stdlib-ext | mruby-time        |
-| Struct                | stdlib-ext | mruby-struct      |
-| Data                  | stdlib-ext | mruby-data        |
-| Random                | stdlib-ext | mruby-random      |
-| IO, File              | stdlib-io  | mruby-io          |
-| Socket                | stdlib-io  | mruby-socket      |
-| Dir                   | stdlib-io  | mruby-dir         |
-| Errno                 | stdlib-io  | mruby-errno       |
-| Math                  | math       | mruby-math        |
-| Rational              | math       | mruby-rational    |
-| Complex               | math       | mruby-complex     |
-| Bigint                | math       | mruby-bigint      |
-| Method, UnboundMethod | metaprog   | mruby-method      |
+| Class/Module | Gembox | Gem |
+| ------------ | ------ | --- |
+| Fiber | stdlib | mruby-fiber |
+| Enumerator | stdlib | mruby-enumerator |
+| Enumerator::Lazy | stdlib | mruby-enum-lazy |
+| Set | stdlib | mruby-set |
+| ObjectSpace | stdlib | mruby-objectspace |
+| Time | stdlib-ext | mruby-time |
+| Struct | stdlib-ext | mruby-struct |
+| Data | stdlib-ext | mruby-data |
+| Random | stdlib-ext | mruby-random |
+| IO, File | stdlib-io | mruby-io |
+| Socket | stdlib-io | mruby-socket |
+| Dir | stdlib-io | mruby-dir |
+| Errno | stdlib-io | mruby-errno |
+| Math | math | mruby-math |
+| Rational | math | mruby-rational |
+| Complex | math | mruby-complex |
+| Bigint | math | mruby-bigint |
+| Method, UnboundMethod | metaprog | mruby-method |

 ### Methods and Features

-| Feature                       | Gembox     | Gem                |
-| ----------------------------- | ---------- | ------------------ |
-| `catch`/`throw`               | stdlib     | mruby-catch        |
-| `Kernel#sprintf`, `String#%`  | stdlib-ext | mruby-sprintf      |
-| `Array#pack`, `String#unpack` | stdlib-ext | mruby-pack         |
-| `Kernel#rand`                 | stdlib-ext | mruby-random       |
-| `Kernel#eval`                 | metaprog   | mruby-eval         |
-| `Kernel#binding`              | metaprog   | mruby-binding      |
-| `Proc#binding`                | metaprog   | mruby-proc-binding |
-| Runtime compiler              | metaprog   | mruby-compiler     |
+| Feature | Gembox | Gem |
+| ------- | ------ | --- |
+| `catch`/`throw` | stdlib | mruby-catch |
+| `Kernel#sprintf`, `String#%` | stdlib-ext | mruby-sprintf |
+| `Array#pack`, `String#unpack` | stdlib-ext | mruby-pack |
+| `Kernel#rand` | stdlib-ext | mruby-random |
+| `Kernel#eval` | metaprog | mruby-eval |
+| `Kernel#binding` | metaprog | mruby-binding |
+| `Proc#binding` | metaprog | mruby-proc-binding |
+| Runtime compiler | metaprog | mruby-compiler |

 ### Core Class Extensions

 The `stdlib` gembox also extends built-in classes with additional
 methods. These are included by default:

-| Extension               | Examples                                       |
-| ----------------------- | ---------------------------------------------- |
-| Array extensions        | `#dig`, `#union`, `#difference`                |
-| Hash extensions         | `#dig`, `#transform_keys`, `#transform_values` |
-| String extensions       | `#encode`, `#bytes`, `#chars`                  |
-| Numeric extensions      | `Integer#digits`, `Integer#pow`                |
-| Comparable extensions   | `#clamp`                                       |
-| Enumerable extensions   | `#sort_by`, `#min_by`, `#max_by`, `#tally`     |
-| Range extensions        | `#size`, `#cover?`                             |
-| Proc extensions         | `#<<`, `#>>` (composition)                     |
-| Symbol extensions       | `#to_proc`                                     |
-| Object extensions       | `#then`, `#yield_self`                         |
-| Kernel extensions       | `#__method__`                                  |
-| Class/Module extensions | `Module#name`                                  |
+| Extension | Examples |
+| --------- | -------- |
+| Array extensions | `#dig`, `#union`, `#difference` |
+| Hash extensions | `#dig`, `#transform_keys`, `#transform_values` |
+| String extensions | `#encode`, `#bytes`, `#chars` |
+| Numeric extensions | `Integer#digits`, `Integer#pow` |
+| Comparable extensions | `#clamp` |
+| Enumerable extensions | `#sort_by`, `#min_by`, `#max_by`, `#tally` |
+| Range extensions | `#size`, `#cover?` |
+| Proc extensions | `#<<`, `#>>` (composition) |
+| Symbol extensions | `#to_proc` |
+| Object extensions | `#then`, `#yield_self` |
+| Kernel extensions | `#__method__` |
+| Class/Module extensions | `Module#name` |

 ### Gembox Summary

-| Gembox       | Contents                                      | Notes                                        |
-| ------------ | --------------------------------------------- | -------------------------------------------- |
-| `stdlib`     | Core class extensions, Fiber, Enumerator, Set | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `stdlib-ext` | Time, Struct, Data, Random, sprintf, pack     | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `stdlib-io`  | IO, File, Dir, Socket, Errno                  | Requires stdio                               |
-| `math`       | Math, Rational, Complex, Bigint               | Works with `MRB_NO_STDIO`                    |
-| `metaprog`   | eval, binding, Method, compiler               | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
-| `default`    | All of the above + CLI tools                  | Full installation                            |
+| Gembox | Contents | Notes |
+| ------ | -------- | ----- |
+| `stdlib` | Core class extensions, Fiber, Enumerator, Set | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `stdlib-ext` | Time, Struct, Data, Random, sprintf, pack | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `stdlib-io` | IO, File, Dir, Socket, Errno | Requires stdio |
+| `math` | Math, Rational, Complex, Bigint | Works with `MRB_NO_STDIO` |
+| `metaprog` | eval, binding, Method, compiler | Works with `MRB_NO_STDIO` and `MRB_NO_FLOAT` |
+| `default` | All of the above + CLI tools | Full installation |

 ## Key Differences from CRuby

@@ -416,15 +416,15 @@ differently on 32-bit or NaN boxing configurations.

 Key compile-time macros that affect language behavior:

-| Macro                | Effect                             |
-| -------------------- | ---------------------------------- |
-| `MRB_NO_FLOAT`       | Remove all float support           |
-| `MRB_USE_FLOAT32`    | Use 32-bit float instead of double |
-| `MRB_UTF8_STRING`    | Enable UTF-8 string handling       |
-| `MRB_INT32`          | Force 32-bit integer               |
-| `MRB_INT64`          | Force 64-bit integer               |
-| `MRB_STR_LENGTH_MAX` | Max string length (default 1MB)    |
-| `MRB_ARY_LENGTH_MAX` | Max array length (default 2^17)    |
+| Macro | Effect |
+| ----- | ------ |
+| `MRB_NO_FLOAT` | Remove all float support |
+| `MRB_USE_FLOAT32` | Use 32-bit float instead of double |
+| `MRB_UTF8_STRING` | Enable UTF-8 string handling |
+| `MRB_INT32` | Force 32-bit integer |
+| `MRB_INT64` | Force 64-bit integer |
+| `MRB_STR_LENGTH_MAX` | Max string length (default 1MB) |
+| `MRB_ARY_LENGTH_MAX` | Max array length (default 2^17) |

 See [mrbconf.md](mrbconf.md) for the complete list of configuration
 macros.
@@ -202,10 +202,10 @@ any other heap page. The only differences are:
 The page size is controlled by `MRB_HEAP_PAGE_SIZE` (default: 1024 slots).
 Each page occupies:

-| Platform | Slot size | Page size (approx) |
-| -------- | --------- | ------------------ |
-| 64-bit   | 40 bytes  | ~41 KB             |
-| 32-bit   | 24 bytes  | ~25 KB             |
+| Platform | Slot size | Page size (approx)  |
+|----------|-----------|---------------------|
+| 64-bit   | 40 bytes  | ~41 KB              |
+| 32-bit   | 24 bytes  | ~25 KB              |

 To estimate pages for a given buffer: `pages = buffer_size / sizeof(mrb_heap_page)`.
 Each page provides `MRB_HEAP_PAGE_SIZE` object slots.
@@ -233,10 +233,10 @@ end
 - Specifies 4th argument(`argc`) max value of `mrb_funcall`.
 - Raises `ArgumentError` when the `argc` argument is bigger then this value `mrb_funcall`.

-`KHASH_INITIAL_SIZE`
+`KHASH_DEFAULT_SIZE`

 - Default value is `32`.
- Specifies initial size of khash table bucket.
+- Specifies default size of khash table bucket.
 - Used in `kh_init_ ## name` function.

 `MRB_NO_METHOD_CACHE`
@@ -272,7 +272,7 @@ deployment targets. Define one of the following:
 `MRB_CONSTRAINED_BASELINE_PROFILE`

 - For micro controllers.
- Enables `MRB_NO_METHOD_CACHE`, reduces `KHASH_INITIAL_SIZE` to `16`,
+- Enables `MRB_NO_METHOD_CACHE`, reduces `KHASH_DEFAULT_SIZE` to `16`,
  and `MRB_HEAP_PAGE_SIZE` to `256`.

 `MRB_BASELINE_PROFILE`
@@ -31,17 +31,17 @@ struct RBasic (8 bytes on 64-bit)

 All object structs embed this header via `MRB_OBJECT_HEADER`:

-| Struct       | Ruby Type        | Extra Fields                       |
-| ------------ | ---------------- | ---------------------------------- |
-| `RObject`    | Object instances | `iv` (instance variables)          |
-| `RClass`     | Class/Module     | `iv`, `mt` (method table), `super` |
-| `RString`    | String           | embedded or heap buffer, length    |
-| `RArray`     | Array            | embedded or heap buffer, length    |
-| `RHash`      | Hash             | hash table or k-v array            |
-| `RProc`      | Proc/Lambda      | `irep` or C function, environment  |
-| `RData`      | C data wrapper   | `void *data`, `mrb_data_type`      |
-| `RFiber`     | Fiber            | `mrb_context`                      |
-| `RException` | Exception        | `iv`                               |
+| Struct | Ruby Type | Extra Fields |
+| ------ | --------- | ------------ |
+| `RObject` | Object instances | `iv` (instance variables) |
+| `RClass` | Class/Module | `iv`, `mt` (method table), `super` |
+| `RString` | String | embedded or heap buffer, length |
+| `RArray` | Array | embedded or heap buffer, length |
+| `RHash` | Hash | hash table or k-v array |
+| `RProc` | Proc/Lambda | `irep` or C function, environment |
+| `RData` | C data wrapper | `void *data`, `mrb_data_type` |
+| `RFiber` | Fiber | `mrb_context` |
+| `RException` | Exception | `iv` |

 Immediate values (Integer, Symbol, `true`, `false`, `nil`) are encoded
 directly in `mrb_value` without heap allocation. The encoding depends on
@@ -111,52 +111,52 @@ See [compiler.md](compiler.md) for detailed compiler internals,

 ### Core (`src/`)

-| File          | Responsibility                                 |
-| ------------- | ---------------------------------------------- |
-| `vm.c`        | Bytecode dispatch loop, method invocation      |
-| `state.c`     | `mrb_state` init/close, irep management        |
-| `gc.c`        | Garbage collector (mark-sweep, incremental)    |
-| `class.c`     | Class/module definition, method tables         |
-| `object.c`    | Core object operations                         |
-| `variable.c`  | Instance/class/global variables, object shapes |
-| `proc.c`      | Proc/Lambda/closure handling                   |
-| `array.c`     | Array implementation                           |
-| `string.c`    | String implementation (embedded, shared, heap) |
-| `hash.c`      | Hash implementation (open addressing)          |
-| `numeric.c`   | Integer/Float arithmetic                       |
-| `symbol.c`    | Symbol table and interning                     |
-| `range.c`     | Range implementation                           |
-| `error.c`     | Exception creation, raise, backtrace           |
-| `kernel.c`    | Kernel module methods                          |
-| `load.c`      | `.mrb` bytecode loading                        |
-| `dump.c`      | Bytecode serialization (write `.mrb`)          |
-| `print.c`     | Print/puts/p output                            |
-| `backtrace.c` | Stack trace generation                         |
+| File | Responsibility |
+| ---- | -------------- |
+| `vm.c` | Bytecode dispatch loop, method invocation |
+| `state.c` | `mrb_state` init/close, irep management |
+| `gc.c` | Garbage collector (mark-sweep, incremental) |
+| `class.c` | Class/module definition, method tables |
+| `object.c` | Core object operations |
+| `variable.c` | Instance/class/global variables, object shapes |
+| `proc.c` | Proc/Lambda/closure handling |
+| `array.c` | Array implementation |
+| `string.c` | String implementation (embedded, shared, heap) |
+| `hash.c` | Hash implementation (open addressing) |
+| `numeric.c` | Integer/Float arithmetic |
+| `symbol.c` | Symbol table and interning |
+| `range.c` | Range implementation |
+| `error.c` | Exception creation, raise, backtrace |
+| `kernel.c` | Kernel module methods |
+| `load.c` | `.mrb` bytecode loading |
+| `dump.c` | Bytecode serialization (write `.mrb`) |
+| `print.c` | Print/puts/p output |
+| `backtrace.c` | Stack trace generation |

 ### Compiler (`mrbgems/mruby-compiler/core/`)

-| File        | Responsibility                  |
-| ----------- | ------------------------------- |
-| `parse.y`   | Yacc grammar → AST              |
-| `y.tab.c`   | Generated parser (from parse.y) |
-| `codegen.c` | AST → bytecode (irep)           |
-| `node.h`    | AST node type definitions       |
+| File | Responsibility |
+| ---- | -------------- |
+| `parse.y` | Yacc grammar → AST |
+| `y.tab.c` | Generated parser (from parse.y) |
+| `codegen.c` | AST → bytecode (irep) |
+| `node.h` | AST node type definitions |

 ### Key Headers (`include/mruby/`)

-| Header       | Contents                              |
-| ------------ | ------------------------------------- |
-| `mruby.h`    | `mrb_state`, core API declarations    |
-| `value.h`    | `mrb_value`, type enums, value macros |
-| `object.h`   | `RBasic`, `RObject`, object header    |
-| `class.h`    | `RClass`, method table types          |
-| `string.h`   | `RString`, string macros              |
-| `array.h`    | `RArray`, array macros                |
-| `hash.h`     | `RHash`, hash API                     |
-| `data.h`     | `RData`, C data wrapping              |
-| `irep.h`     | `mrb_irep`, bytecode structures       |
-| `compile.h`  | Compiler context, `mrb_load_string`   |
-| `boxing_*.h` | Value boxing implementations          |
+| Header | Contents |
+| ------ | -------- |
+| `mruby.h` | `mrb_state`, core API declarations |
+| `value.h` | `mrb_value`, type enums, value macros |
+| `object.h` | `RBasic`, `RObject`, object header |
+| `class.h` | `RClass`, method table types |
+| `string.h` | `RString`, string macros |
+| `array.h` | `RArray`, array macros |
+| `hash.h` | `RHash`, hash API |
+| `data.h` | `RData`, C data wrapping |
+| `irep.h` | `mrb_irep`, bytecode structures |
+| `compile.h` | Compiler context, `mrb_load_string` |
+| `boxing_*.h` | Value boxing implementations |

 ## mrbgems System

@@ -77,16 +77,16 @@ No boxing represents `mrb_value` by the C struct with `type` and the value union

 ## Comparison

-| Property               | Word Boxing       | NaN Boxing       | No Boxing            |
-| ---------------------- | ----------------- | ---------------- | -------------------- |
-| `mrb_value` size       | 1 word (4/8 byte) | 8 bytes          | 2 words (8/16 bytes) |
-| Default on             | most platforms    | (manual opt-in)  | `host-debug`         |
-| Macro                  | `MRB_WORD_BOXING` | `MRB_NAN_BOXING` | `MRB_NO_BOXING`      |
-| Inline integers        | yes (31/63 bit)   | yes (32 bit)     | yes (full width)     |
-| Inline floats (64-bit) | yes (rotation)    | yes (native)     | yes (struct field)   |
-| Inline floats (32-bit) | no (heap RFloat)  | yes (native)     | yes (struct field)   |
-| Pointer size limit     | none              | 48 bits          | none                 |
-| Debugger friendly      | no                | no               | yes                  |
+| Property               | Word Boxing        | NaN Boxing         | No Boxing            |
+| ---------------------- | ------------------ | ------------------ | -------------------- |
+| `mrb_value` size       | 1 word (4/8 byte)  | 8 bytes            | 2 words (8/16 bytes) |
+| Default on             | most platforms     | (manual opt-in)    | `host-debug`         |
+| Macro                  | `MRB_WORD_BOXING`  | `MRB_NAN_BOXING`   | `MRB_NO_BOXING`      |
+| Inline integers        | yes (31/63 bit)    | yes (32 bit)       | yes (full width)     |
+| Inline floats (64-bit) | yes (rotation)     | yes (native)       | yes (struct field)   |
+| Inline floats (32-bit) | no (heap RFloat)   | yes (native)       | yes (struct field)   |
+| Pointer size limit     | none               | 48 bits            | none                 |
+| Debugger friendly      | no                 | no                 | yes                  |

 ## ABI Compatibility

@@ -40,18 +40,18 @@ file: `mrbgems/mruby-compiler/core/parse.y`.

 The parser maintains extensive state in `mrb_parser_state`:

- **lstate**: current lexer state (EXPR_BEG, EXPR_END, EXPR_ARG,
-  EXPR_DOT, EXPR_FNAME, etc.). Controls how tokens like `+`/`-`
+- **lstate**: current lexer state (EXPR\_BEG, EXPR\_END, EXPR\_ARG,
+  EXPR\_DOT, EXPR\_FNAME, etc.). Controls how tokens like `+`/`-`
  are interpreted (sign vs operator) and whether newlines are
  significant.
 - **locals**: stack of local variable lists (one per scope), stored
  as cons-lists of symbols.
- **lex_strterm**: string/heredoc parsing state for handling nested
+- **lex\_strterm**: string/heredoc parsing state for handling nested
  interpolation.
- **cond_stack**, **cmdarg_stack**: bit stacks tracking
+- **cond\_stack**, **cmdarg\_stack**: bit stacks tracking
  conditional and command argument contexts.
 - **tree**: root AST node after successful parse.
- **error_buffer**: accumulated parse errors.
+- **error\_buffer**: accumulated parse errors.

 ### AST Nodes

@@ -123,10 +123,10 @@ reuse temporaries within an expression.
 Instructions are emitted via helper functions:

 - `genop_0(opcode)`: no operands
- `genop_1(opcode, a)`: one operand (auto-extends with OP_EXT1
+- `genop_1(opcode, a)`: one operand (auto-extends with OP\_EXT1
  if a > 255)
 - `genop_2(opcode, a, b)`: two operands (auto-extends with
-  OP_EXT1/2/3 as needed)
+  OP\_EXT1/2/3 as needed)
 - `genop_3(opcode, a, b, c)`: three operands
 - `genop_W(opcode, a)`: 24-bit operand
 - `genop_2S(opcode, a, b)`: one 8-bit + one 16-bit operand
@@ -176,14 +176,14 @@ mrb_irep

 Pool entries store constants referenced by instructions:

-| Type             | Tag | Description                     |
-| ---------------- | --- | ------------------------------- |
-| `IREP_TT_STR`    | 0   | Dynamic string (heap allocated) |
-| `IREP_TT_SSTR`   | 2   | Static string (read-only)       |
-| `IREP_TT_INT32`  | 1   | 32-bit integer                  |
-| `IREP_TT_INT64`  | 3   | 64-bit integer                  |
-| `IREP_TT_FLOAT`  | 5   | Floating-point number           |
-| `IREP_TT_BIGINT` | 7   | Arbitrary-precision integer     |
+| Type | Tag | Description |
+| ---- | --- | ----------- |
+| `IREP_TT_STR` | 0 | Dynamic string (heap allocated) |
+| `IREP_TT_SSTR` | 2 | Static string (read-only) |
+| `IREP_TT_INT32` | 1 | 32-bit integer |
+| `IREP_TT_INT64` | 3 | 64-bit integer |
+| `IREP_TT_FLOAT` | 5 | Floating-point number |
+| `IREP_TT_BIGINT` | 7 | Arbitrary-precision integer |

 The code generator deduplicates pool entries: identical strings
 and equal numeric values share the same pool index.
@@ -209,28 +209,28 @@ During exception unwinding, handlers are searched in reverse order
 Standard instructions use 8-bit operands. When a value exceeds
 255, extension prefixes widen operands to 16 bits:

-| Prefix    | Effect                            |
-| --------- | --------------------------------- |
-| `OP_EXT1` | First operand (a) becomes 16-bit  |
+| Prefix | Effect |
+| ------ | ------ |
+| `OP_EXT1` | First operand (a) becomes 16-bit |
 | `OP_EXT2` | Second operand (b) becomes 16-bit |
-| `OP_EXT3` | Both a and b become 16-bit        |
+| `OP_EXT3` | Both a and b become 16-bit |

 Instruction formats:

-| Format | Layout                        | Size    |
-| ------ | ----------------------------- | ------- |
-| Z      | opcode only                   | 1 byte  |
-| B      | opcode + a(8)                 | 2 bytes |
-| BB     | opcode + a(8) + b(8)          | 3 bytes |
-| BBB    | opcode + a(8) + b(8) + c(8)   | 4 bytes |
-| BS     | opcode + a(8) + b(16)         | 4 bytes |
-| BSS    | opcode + a(8) + b(16) + c(16) | 6 bytes |
-| S      | opcode + a(16)                | 3 bytes |
-| W      | opcode + a(24)                | 4 bytes |
+| Format | Layout | Size |
+| ------ | ------ | ---- |
+| Z | opcode only | 1 byte |
+| B | opcode + a(8) | 2 bytes |
+| BB | opcode + a(8) + b(8) | 3 bytes |
+| BBB | opcode + a(8) + b(8) + c(8) | 4 bytes |
+| BS | opcode + a(8) + b(16) | 4 bytes |
+| BSS | opcode + a(8) + b(16) + c(16) | 6 bytes |
+| S | opcode + a(16) | 3 bytes |
+| W | opcode + a(24) | 4 bytes |

 See [opcode.md](opcode.md) for the full instruction table.

-## OP_ENTER: Argument Specification
+## OP\_ENTER: Argument Specification

 `OP_ENTER` encodes a method's argument layout in a 24-bit value
 (W format). The bit fields are defined by the `MRB_ARGS_*` macros:
@@ -258,16 +258,16 @@ string interning for common symbols.
 Generated by `lib/mruby/presym.rb`, the presym table maps symbol
 names to compile-time constants:

-| Macro             | Example               | Symbol        |
-| ----------------- | --------------------- | ------------- |
-| `MRB_SYM(name)`   | `MRB_SYM(initialize)` | `:initialize` |
-| `MRB_SYM_B(name)` | `MRB_SYM_B(map)`      | `:map!`       |
-| `MRB_SYM_Q(name)` | `MRB_SYM_Q(nil)`      | `:nil?`       |
-| `MRB_SYM_E(name)` | `MRB_SYM_E(name)`     | `:name=`      |
-| `MRB_OPSYM(op)`   | `MRB_OPSYM(add)`      | `:+`          |
-| `MRB_IVSYM(name)` | `MRB_IVSYM(name)`     | `:@name`      |
-| `MRB_CVSYM(name)` | `MRB_CVSYM(count)`    | `:@@count`    |
-| `MRB_GVSYM(name)` | `MRB_GVSYM(stdout)`   | `:$stdout`    |
+| Macro | Example | Symbol |
+| ----- | ------- | ------ |
+| `MRB_SYM(name)` | `MRB_SYM(initialize)` | `:initialize` |
+| `MRB_SYM_B(name)` | `MRB_SYM_B(map)` | `:map!` |
+| `MRB_SYM_Q(name)` | `MRB_SYM_Q(nil)` | `:nil?` |
+| `MRB_SYM_E(name)` | `MRB_SYM_E(name)` | `:name=` |
+| `MRB_OPSYM(op)` | `MRB_OPSYM(add)` | `:+` |
+| `MRB_IVSYM(name)` | `MRB_IVSYM(name)` | `:@name` |
+| `MRB_CVSYM(name)` | `MRB_CVSYM(count)` | `:@@count` |
+| `MRB_GVSYM(name)` | `MRB_GVSYM(stdout)` | `:$stdout` |

 ## Binary Format (.mrb)

@@ -299,25 +299,25 @@ mrbc -Boutput source.rb           # C array format

 ## Compilation Limits

-| Limit                  | Value                         |
-| ---------------------- | ----------------------------- |
-| Max nesting depth      | 256 (`MRB_CODEGEN_LEVEL_MAX`) |
-| Max local variables    | 255 (uint16 `nlocals`)        |
-| Max symbols per irep   | 65535                         |
-| Max operand (standard) | 255 (8-bit)                   |
-| Max operand (extended) | 65535 (16-bit)                |
+| Limit | Value |
+| ----- | ----- |
+| Max nesting depth | 256 (`MRB_CODEGEN_LEVEL_MAX`) |
+| Max local variables | 255 (uint16 `nlocals`) |
+| Max symbols per irep | 65535 |
+| Max operand (standard) | 255 (8-bit) |
+| Max operand (extended) | 65535 (16-bit) |

 ## Source Files

-| File                                    | Contents                  |
-| --------------------------------------- | ------------------------- |
-| `mrbgems/mruby-compiler/core/parse.y`   | Lrama/Bison grammar       |
-| `mrbgems/mruby-compiler/core/y.tab.c`   | Generated parser          |
-| `mrbgems/mruby-compiler/core/codegen.c` | Code generator            |
-| `mrbgems/mruby-compiler/core/node.h`    | AST node types            |
-| `include/mruby/irep.h`                  | IRep structure definition |
-| `include/mruby/compile.h`               | Compiler context API      |
-| `include/mruby/ops.h`                   | Opcode definitions        |
-| `src/load.c`                            | Binary format loader      |
-| `src/dump.c`                            | Binary format writer      |
-| `lib/mruby/presym.rb`                   | Presym table generator    |
+| File | Contents |
+| ---- | -------- |
+| `mrbgems/mruby-compiler/core/parse.y` | Lrama/Bison grammar |
+| `mrbgems/mruby-compiler/core/y.tab.c` | Generated parser |
+| `mrbgems/mruby-compiler/core/codegen.c` | Code generator |
+| `mrbgems/mruby-compiler/core/node.h` | AST node types |
+| `include/mruby/irep.h` | IRep structure definition |
+| `include/mruby/compile.h` | Compiler context API |
+| `include/mruby/ops.h` | Opcode definitions |
+| `src/load.c` | Binary format loader |
+| `src/dump.c` | Binary format writer |
+| `lib/mruby/presym.rb` | Presym table generator |
@@ -26,12 +26,12 @@ pauses.
 Every heap-allocated object has a color stored in
 `RBasic::gc_color` (3 bits):

-| Color          | Value  | Meaning                              |
-| -------------- | ------ | ------------------------------------ |
-| White (A or B) | 1 or 2 | Unmarked, candidate for collection   |
-| Gray           | 0      | Marked, but children not yet scanned |
-| Black          | 4      | Fully marked and scanned             |
-| Red            | 7      | Static/ROM object, never collected   |
+| Color | Value | Meaning |
+| ----- | ----- | ------- |
+| White (A or B) | 1 or 2 | Unmarked, candidate for collection |
+| Gray | 0 | Marked, but children not yet scanned |
+| Black | 4 | Fully marked and scanned |
+| Red | 7 | Static/ROM object, never collected |

 The GC uses two white types (A and B) in a flip-flop scheme. At the
 start of each GC cycle, the meaning of "current white" is flipped by
@@ -107,7 +107,7 @@ The GC operates as a three-state machine:
 GC_STATE_ROOT --> GC_STATE_MARK --> GC_STATE_SWEEP --> GC_STATE_ROOT
 ```

-### Root Scan (GC_STATE_ROOT)
+### Root Scan (GC\_STATE\_ROOT)

 Marks objects directly reachable from the VM:

@@ -121,7 +121,7 @@ Marks objects directly reachable from the VM:

 After root scanning, the white color is flipped.

-### Incremental Marking (GC_STATE_MARK)
+### Incremental Marking (GC\_STATE\_MARK)

 Gray objects are popped from the gray stack and their children
 marked. Each step processes a limited number of objects:
@@ -137,7 +137,7 @@ When the gray stack is exhausted, the final marking phase re-marks
 the arena and global variables to catch objects created during
 marking, then transitions to sweep.

-### Sweep (GC_STATE_SWEEP)
+### Sweep (GC\_STATE\_SWEEP)

 Iterates through heap pages. For each object:

@@ -325,15 +325,15 @@ From Ruby: `GC.start`.

 ### Compile-Time

-| Macro                          | Default | Description                             |
-| ------------------------------ | ------- | --------------------------------------- |
-| `MRB_HEAP_PAGE_SIZE`           | 1024    | Objects per heap page                   |
-| `MRB_GRAY_STACK_SIZE`          | 1024    | Gray stack capacity                     |
-| `MRB_GC_ARENA_SIZE`            | 100     | Arena size (fixed mode) or initial size |
-| `MRB_GC_FIXED_ARENA`           | off     | Use fixed-size arena                    |
-| `MRB_GC_TURN_OFF_GENERATIONAL` | off     | Disable generational mode               |
-| `MRB_GC_STRESS`                | off     | Full GC on every allocation (debug)     |
-| `MRB_USE_MALLOC_TRIM`          | off     | Call `malloc_trim()` after full GC      |
+| Macro | Default | Description |
+| ----- | ------- | ----------- |
+| `MRB_HEAP_PAGE_SIZE` | 1024 | Objects per heap page |
+| `MRB_GRAY_STACK_SIZE` | 1024 | Gray stack capacity |
+| `MRB_GC_ARENA_SIZE` | 100 | Arena size (fixed mode) or initial size |
+| `MRB_GC_FIXED_ARENA` | off | Use fixed-size arena |
+| `MRB_GC_TURN_OFF_GENERATIONAL` | off | Disable generational mode |
+| `MRB_GC_STRESS` | off | Full GC on every allocation (debug) |
+| `MRB_USE_MALLOC_TRIM` | off | Call `malloc_trim()` after full GC |

 ### Runtime

@@ -350,8 +350,8 @@ GC.disable                 # disable GC

 ## Source Files

-| File                 | Contents                          |
-| -------------------- | --------------------------------- |
-| `src/gc.c`           | GC implementation (~1400 lines)   |
+| File | Contents |
+| ---- | -------- |
+| `src/gc.c` | GC implementation (~1400 lines) |
 | `include/mruby/gc.h` | `mrb_gc` structure, public GC API |
-| `include/mruby.h`    | Arena save/restore macros         |
+| `include/mruby.h` | Arena save/restore macros |
@@ -97,12 +97,12 @@ return n + 1 (skip self)

 ### Call Context Info (cci)

-| Value | Name            | Meaning                               |
-| ----- | --------------- | ------------------------------------- |
-| 0     | `CINFO_NONE`    | Normal VM-to-VM call                  |
-| 1     | `CINFO_DIRECT`  | Explicit VM call (block, lambda.call) |
-| 2     | `CINFO_SKIP`    | Skip frame in stack traces            |
-| 3     | `CINFO_RESUMED` | Fiber resumed (stop execution)        |
+| Value | Name | Meaning |
+| ----- | ---- | ------- |
+| 0 | `CINFO_NONE` | Normal VM-to-VM call |
+| 1 | `CINFO_DIRECT` | Explicit VM call (block, lambda.call) |
+| 2 | `CINFO_SKIP` | Skip frame in stack traces |
+| 3 | `CINFO_RESUMED` | Fiber resumed (stop execution) |

 ## Dispatch Loop

@@ -241,13 +241,13 @@ correctness.

 ### Proc Types

-| Flag                | Meaning                        |
-| ------------------- | ------------------------------ |
-| `MRB_PROC_CFUNC_FL` | C function (not irep-based)    |
-| `MRB_PROC_STRICT`   | Lambda (strict argument check) |
-| `MRB_PROC_ORPHAN`   | No environment attachment      |
-| `MRB_PROC_ENVSET`   | Has captured environment       |
-| `MRB_PROC_SCOPE`    | Defines a new variable scope   |
+| Flag | Meaning |
+| ---- | ------- |
+| `MRB_PROC_CFUNC_FL` | C function (not irep-based) |
+| `MRB_PROC_STRICT` | Lambda (strict argument check) |
+| `MRB_PROC_ORPHAN` | No environment attachment |
+| `MRB_PROC_ENVSET` | Has captured environment |
+| `MRB_PROC_SCOPE` | Defines a new variable scope |

 ## Fiber Switching

@@ -317,9 +317,9 @@ ensuring the incremental GC correctly tracks live references.

 ## Source Files

-| File                    | Contents                                       |
-| ----------------------- | ---------------------------------------------- |
-| `src/vm.c`              | Dispatch loop, method invocation (~1900 lines) |
-| `include/mruby.h`       | `mrb_state`, `mrb_callinfo`, `mrb_context`     |
-| `include/mruby/proc.h`  | `RProc`, `REnv` structures                     |
-| `include/mruby/throw.h` | `MRB_TRY`/`MRB_CATCH` macros                   |
+| File | Contents |
+| ---- | -------- |
+| `src/vm.c` | Dispatch loop, method invocation (~1900 lines) |
+| `include/mruby.h` | `mrb_state`, `mrb_callinfo`, `mrb_context` |
+| `include/mruby/proc.h` | `RProc`, `REnv` structures |
+| `include/mruby/throw.h` | `MRB_TRY`/`MRB_CATCH` macros |
@@ -274,11 +274,11 @@ enabled with the `MRB_UTF8_STRING` compile flag.

 Integer size depends on the value boxing configuration:

-| Configuration                 | Integer range    |
-| ----------------------------- | ---------------- |
+| Configuration | Integer range |
+| ------------- | ------------- |
 | Word boxing, 64-bit (default) | roughly +/- 2^62 |
 | Word boxing, 32-bit (default) | roughly +/- 2^30 |
-| NaN boxing (64-bit only)      | -2^31 to 2^31-1  |
+| NaN boxing (64-bit only) | -2^31 to 2^31-1 |

 Code relying on 64-bit integer precision may behave differently
 across configurations. The `mruby-bigint` gem provides
@@ -138,8 +138,8 @@
 /* turn off generational GC by default */
 //#define MRB_GC_TURN_OFF_GENERATIONAL

-/* initial size of khash table bucket */
-//#define KHASH_INITIAL_SIZE 32
+/* default size of khash table bucket */
+//#define KHASH_DEFAULT_SIZE 32

 /* allocated memory address alignment */
 //#define POOL_ALIGNMENT 4
@@ -208,8 +208,8 @@
 #  define MRB_NO_METHOD_CACHE
 # endif

-# ifndef KHASH_INITIAL_SIZE
-#  define KHASH_INITIAL_SIZE 16
+# ifndef KHASH_DEFAULT_SIZE
+#  define KHASH_DEFAULT_SIZE 16
 # endif

 # ifndef MRB_HEAP_PAGE_SIZE
@@ -21,7 +21,7 @@ typedef uint32_t khint_t;
 typedef khint_t khiter_t;

 #ifndef KHASH_INITIAL_SIZE
-# define KHASH_INITIAL_SIZE 32
+# define KHASH_INITIAL_SIZE 8
 #endif
 #define KHASH_MIN_SIZE 8
 #define KHASH_SMALL_LIMIT 4
@@ -316,11 +316,7 @@ struct RCptr {
 #endif
 #define mrb_test(o)   mrb_bool(o)
 #ifndef mrb_bigint_p
-#ifdef MRB_USE_BIGINT
 #define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
-#else
-#define mrb_bigint_p(o) FALSE
-#endif
 #endif

 /**
@@ -109,8 +109,7 @@ module MRuby
        if build.kind_of?(MRuby::CrossBuild)
          return %w(x86_64-w64-mingw32 i686-w64-mingw32).include?(build.host_target)
        elsif build.kind_of?(MRuby::Build)
-          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") } ||
-                 ('a'..'z').to_a.any? { |vol| Dir.exist?("/#{vol}/") }
+          return ('A'..'Z').to_a.any? { |vol| Dir.exist?("#{vol}:") }
        end
        return false
      end
@@ -611,15 +611,37 @@ class Array
  #   ary.product(*arys)                  ->   array
  #   ary.product(*arys) { |item| ... }   ->   self
  def product(*arys, &block)
-    gen = __product_generate(arys, &block)
-    return gen unless block
-
-    if gen
-      while group = __product_next(arys, gen)
-        yield group
+    size = arys.size
+    i = size
+    while i > 0
+      i -= 1
+      unless arys[i].kind_of?(Array)
+        raise TypeError, "no implicit conversion into Array"
      end
    end
-    self
+
+    i = size
+    total = self.size
+    total *= arys[i -= 1].size while i > 0
+
+    if block
+      i = 0
+      while i < total
+        group = self.__product_group(arys, i, size + 1)
+        block.call(group)
+        i += 1
+      end
+      return self
+    else
+      result = [nil] * total
+      i = 0
+      while i < total
+        group = self.__product_group(arys, i, size + 1)
+        result[i] = group
+        i += 1
+      end
+      return result
+    end
  end

  ##
@@ -6,7 +6,6 @@
 #include <mruby/hash.h>
 #include <mruby/data.h>
 #include <mruby/class.h>
-#include <mruby/numeric.h>
 #include <mruby/internal.h>
 #include <mruby/khash.h>
 #include <mruby/error.h>
@@ -79,14 +78,11 @@ ary_assoc(mrb_state *mrb, mrb_value ary)
 {
  mrb_value k = mrb_get_arg1(mrb);

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
    mrb_value v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
-    mrb_gc_protect(mrb, v); // v may be removed from ary by mrb_equal()
    if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 &&
        mrb_equal(mrb, RARRAY_PTR(v)[0], k))
      return v;
-    mrb_gc_arena_restore(mrb, ai);
  }
  return mrb_nil_value();
 }
@@ -110,15 +106,12 @@ ary_rassoc(mrb_state *mrb, mrb_value ary)
 {
  mrb_value value = mrb_get_arg1(mrb);

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
    mrb_value v = RARRAY_PTR(ary)[i];
-    mrb_gc_protect(mrb, v); // v may be removed from ary by mrb_equal()
    if (mrb_array_p(v) &&
        RARRAY_LEN(v) > 1 &&
        mrb_equal(mrb, RARRAY_PTR(v)[1], value))
      return v;
-    mrb_gc_arena_restore(mrb, ai);
  }
  return mrb_nil_value();
 }
@@ -416,12 +409,9 @@ ary_init_temp_set(mrb_state *mrb, ary_set_t *set, mrb_int capacity)
 static void
 ary_populate_temp_set(mrb_state *mrb, ary_set_t *set, mrb_value ary)
 {
-  int ai = mrb_gc_arena_save(mrb);
-  for (mrb_int i = 0; i < RARRAY_LEN(ary); i++) {
-    mrb_value p = RARRAY_PTR(ary)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from ary by kh_put(ary_set, ...)
-    kh_put(ary_set, mrb, set, p);
-    mrb_gc_arena_restore(mrb, ai);
+  mrb_int len = RARRAY_LEN(ary);
+  for (mrb_int i = 0; i < len; i++) {
+    kh_put(ary_set, mrb, set, RARRAY_PTR(ary)[i]);
  }
 }

@@ -470,15 +460,12 @@ ary_subtract_body(mrb_state *mrb, void *data)
    ary_populate_temp_set(mrb, ctx->set, ctx->argv[i]);
  }

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->self); i++) {
    mrb_value p = RARRAY_PTR(ctx->self)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from self by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
    if (kh_is_end(ctx->set, k)) {  /* key doesn't exist in any ary */
      mrb_ary_push(mrb, ctx->result, p);
    }
-    mrb_gc_arena_restore(mrb, ai);
  }

  return ctx->result;
@@ -512,13 +499,13 @@ ary_subtract_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_va
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
+    mrb_int self_len = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < self_len; i++) {
      mrb_value p = RARRAY_PTR(self)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from self by mrb_equal()
      mrb_bool found = FALSE;
      for (mrb_int j = 0; j < argc; j++) {
-        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
+        mrb_int len = RARRAY_LEN(argv[j]);
+        for (mrb_int k = 0; k < len; k++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
            found = TRUE;
            break;
@@ -529,7 +516,6 @@ ary_subtract_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_va
      if (!found) {
        mrb_ary_push(mrb, result, p);
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -573,10 +559,12 @@ ary_difference(mrb_state *mrb, mrb_value self)
  return ary_subtract_internal(mrb, self, argc, argv);
 }

+
 static void
 add_uniq(mrb_state *mrb, mrb_value item, mrb_value result)
 {
-  for (mrb_int i = 0; i < RARRAY_LEN(result); i++) {
+  const mrb_int len = RARRAY_LEN(result);
+  for (mrb_int i = 0; i < len; i++) {
    if (mrb_eql(mrb, item, RARRAY_PTR(result)[i])) {
      return;
    }
@@ -596,18 +584,15 @@ static mrb_value
 ary_union_body(mrb_state *mrb, void *data)
 {
  struct ary_union_ctx *ctx = (struct ary_union_ctx *)data;
-  int ai = mrb_gc_arena_save(mrb);

  /* Add unique elements from self */
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->self_copy); i++) {
    mrb_value elem = RARRAY_PTR(ctx->self_copy)[i];
-    mrb_gc_protect(mrb, elem); // elem may be removed from self_copy by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
    if (kh_is_end(ctx->set, k)) {
      kh_put(ary_set, mrb, ctx->set, elem);
      mrb_ary_push(mrb, ctx->result, elem);
    }
-    mrb_gc_arena_restore(mrb, ai);
  }

  /* Add unique elements from others */
@@ -615,13 +600,11 @@ ary_union_body(mrb_state *mrb, void *data)
    mrb_value other = ctx->argv[i];
    for (mrb_int j = 0; j < RARRAY_LEN(other); j++) {
      mrb_value elem = RARRAY_PTR(other)[j];
-      mrb_gc_protect(mrb, elem); // elem may be removed from other by kh_get(ary_set, ...)
      khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
      if (kh_is_end(ctx->set, k)) {
        kh_put(ary_set, mrb, ctx->set, elem);
        mrb_ary_push(mrb, ctx->result, elem);
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -653,25 +636,19 @@ ary_union_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mrb_value
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-
    /* Use linear search for small arrays */
    /* Add unique elements from self */
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
-      mrb_value p = RARRAY_PTR(self)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from self by add_uniq()
-      add_uniq(mrb, p, result);
-      mrb_gc_arena_restore(mrb, ai);
+    mrb_int alen = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < alen; i++) {
+      add_uniq(mrb, RARRAY_PTR(self)[i], result);
    }

    /* Add unique elements from others */
    for (mrb_int i = 0; i < argc; i++) {
      mrb_value other = argv[i];
-      for (mrb_int j = 0; j < RARRAY_LEN(other); j++) {
-        mrb_value p = RARRAY_PTR(other)[j];
-        mrb_gc_protect(mrb, p); // p may be removed from other by add_uniq()
-        add_uniq(mrb, p, result);
-        mrb_gc_arena_restore(mrb, ai);
+      mrb_int olen = RARRAY_LEN(other);
+      for (mrb_int j = 0; j < olen; j++) {
+        add_uniq(mrb, RARRAY_PTR(other)[j], result);
      }
    }
  }
@@ -734,16 +711,13 @@ ary_intersection_body(mrb_state *mrb, void *data)
    ary_populate_temp_set(mrb, ctx->set, ctx->argv[i]);
  }

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->self); i++) {
    mrb_value p = RARRAY_PTR(ctx->self)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from self by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
    if (!kh_is_end(ctx->set, k)) {
      mrb_ary_push(mrb, ctx->result, p);
      kh_del(ary_set, mrb, ctx->set, k);
    }
-    mrb_gc_arena_restore(mrb, ai);
  }

  return ctx->result;
@@ -777,15 +751,15 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int i = 0; i < RARRAY_LEN(self); i++) {
+    mrb_int self_len = RARRAY_LEN(self);
+    for (mrb_int i = 0; i < self_len; i++) {
      mrb_value p = RARRAY_PTR(self)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from self by mrb_equal()
      mrb_bool found_in_all = TRUE;

      for (mrb_int j = 0; j < argc; j++) {
        mrb_bool found_in_current_other = FALSE;
-        for (mrb_int k = 0; k < RARRAY_LEN(argv[j]); k++) {
+        mrb_int len = RARRAY_LEN(argv[j]);
+        for (mrb_int k = 0; k < len; k++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(argv[j])[k])) {
            found_in_current_other = TRUE;
            break;
@@ -799,7 +773,8 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr

      if (found_in_all) {
        mrb_bool already_added = FALSE;
-        for (mrb_int j = 0; j < RARRAY_LEN(result); j++) {
+        mrb_int result_len = RARRAY_LEN(result);
+        for (mrb_int j = 0; j < result_len; j++) {
          if (mrb_equal(mrb, p, RARRAY_PTR(result)[j])) {
            already_added = TRUE;
            break;
@@ -809,7 +784,6 @@ ary_intersection_internal(mrb_state *mrb, mrb_value self, mrb_int argc, const mr
          mrb_ary_push(mrb, result, p);
        }
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }
  return result;
@@ -880,12 +854,8 @@ ary_intersect_p_body(mrb_state *mrb, void *data)

  ary_populate_temp_set(mrb, ctx->set, ctx->shorter_ary_copy);

-  int ai = mrb_gc_arena_save(mrb);
  for (mrb_int i = 0; i < RARRAY_LEN(ctx->longer_ary); i++) {
-    mrb_value p = RARRAY_PTR(ctx->longer_ary)[i];
-    mrb_gc_protect(mrb, p); // p may be removed from longer_ary by kh_get(ary_set, ...)
-    khiter_t k = kh_get(ary_set, mrb, ctx->set, p);
-    mrb_gc_arena_restore(mrb, ai);
+    khiter_t k = kh_get(ary_set, mrb, ctx->set, RARRAY_PTR(ctx->longer_ary)[i]);
    if (!kh_is_end(ctx->set, k)) {
      *ctx->found = TRUE;
      break;
@@ -935,16 +905,12 @@ ary_intersect_p(mrb_state *mrb, mrb_value self)
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
    for (mrb_int i = 0; i < RARRAY_LEN(longer_ary); i++) {
-      mrb_value p = RARRAY_PTR(longer_ary)[i];
-      mrb_gc_protect(mrb, p); // p may be removed from longer_ary by mrb_equal()
      for (mrb_int j = 0; j < RARRAY_LEN(shorter_ary); j++) {
-        if (mrb_equal(mrb, p, RARRAY_PTR(shorter_ary)[j])) {
+        if (mrb_equal(mrb, RARRAY_PTR(longer_ary)[i], RARRAY_PTR(shorter_ary)[j])) {
          return mrb_true_value();
        }
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1075,7 +1041,6 @@ ary_fill_exec(mrb_state *mrb, mrb_value self)
  }

  /* Fill the array */
-  mrb_ary_modify(mrb, ary);
  mrb_value *ptr = ARY_PTR(ary) + start;
  for (mrb_int i = 0; i < length; i++) {
    ptr[i] = obj;
@@ -1093,6 +1058,7 @@ struct ary_uniq_bang_ctx {
  mrb_value self_copy;
  mrb_value self;
  mrb_int *write_pos;
+  mrb_int len;
 };

 static mrb_value
@@ -1102,19 +1068,15 @@ ary_uniq_bang_body(mrb_state *mrb, void *data)

  ary_populate_temp_set(mrb, ctx->set, ctx->self_copy);

-  int ai = mrb_gc_arena_save(mrb);
-  for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(ctx->self); read_pos++) {
+  for (mrb_int read_pos = 0; read_pos < ctx->len; read_pos++) {
    mrb_value elem = RARRAY_PTR(ctx->self)[read_pos];
-    mrb_gc_protect(mrb, elem); // elem may be removed from self by kh_get(ary_set, ...)
    khiter_t k = kh_get(ary_set, mrb, ctx->set, elem);
    if (!kh_is_end(ctx->set, k)) {
-      if (*ctx->write_pos != read_pos && *ctx->write_pos < RARRAY_LEN(ctx->self)) {
-        mrb_ary_modify(mrb, mrb_ary_ptr(ctx->self));
+      if (*ctx->write_pos != read_pos) {
        RARRAY_PTR(ctx->self)[*ctx->write_pos] = elem;
      }
      (*ctx->write_pos)++;
      kh_del(ary_set, mrb, ctx->set, k);
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1141,32 +1103,28 @@ ary_uniq_bang(mrb_state *mrb, mrb_value self)
    ary_set_t *set = &set_struct;
    ary_init_temp_set(mrb, set, len);

-    struct ary_uniq_bang_ctx ctx = { set, self_copy, self, &write_pos };
+    struct ary_uniq_bang_ctx ctx = { set, self_copy, self, &write_pos, len };
    mrb_value result;
    MRB_ENSURE(mrb, result, ary_uniq_bang_body, &ctx) {
      ary_destroy_temp_set(mrb, set);
    }
  }
  else {
-    int ai = mrb_gc_arena_save(mrb);
-    for (mrb_int read_pos = 0; read_pos < RARRAY_LEN(self); read_pos++) {
+    for (mrb_int read_pos = 0; read_pos < len; read_pos++) {
      mrb_value elem = RARRAY_PTR(self)[read_pos];
-      mrb_gc_protect(mrb, elem); // elem may be removed from self by mrb_equal()
      mrb_bool found = FALSE;
-      for (mrb_int j = 0; j < write_pos && j < RARRAY_LEN(self); j++) {
+      for (mrb_int j = 0; j < write_pos; j++) {
        if (mrb_equal(mrb, elem, RARRAY_PTR(self)[j])) {
          found = TRUE;
          break;
        }
      }
      if (!found) {
-        if (write_pos != read_pos && write_pos < RARRAY_LEN(self)) {
-          mrb_ary_modify(mrb, mrb_ary_ptr(self));
+        if (write_pos != read_pos) {
          RARRAY_PTR(self)[write_pos] = elem;
        }
        write_pos++;
      }
-      mrb_gc_arena_restore(mrb, ai);
    }
  }

@@ -1415,13 +1373,6 @@ ary_insert(mrb_state *mrb, mrb_value self)
  return self;
 }

-struct ary_product_generator {
-  mrb_int total;
-  mrb_int cursor;
-};
-
-static struct mrb_data_type ary_product_generator_type = { "ary_product_generator", mrb_free };
-
 /*
 *  Internal helper for Array#product to construct a group array.
 *  Takes the base array (self), the array of other arrays (arys),
@@ -1429,85 +1380,29 @@ static struct mrb_data_type ary_product_generator_type = { "ary_product_generato
 *  of the group array (group_len).
 */
 static mrb_value
-ary_product_fetch(mrb_state *mrb, mrb_value self_ary, mrb_value arys_ary, mrb_int n)
+ary_product_group(mrb_state *mrb, mrb_value self_ary)
 {
-  mrb_int j = RARRAY_LEN(arys_ary); // Corresponds to 'size' in Ruby
-  mrb_value group = mrb_ary_new_capa(mrb, j + 1 /* self_ary */);
+  mrb_value arys_ary;
+  mrb_int current_i, group_len;
+  mrb_get_args(mrb, "Aii", &arys_ary, &current_i, &group_len);

-  while (j-- > 0) {
+  mrb_value group = mrb_ary_new_capa(mrb, group_len);
+  mrb_int j = RARRAY_LEN(arys_ary); // Corresponds to 'size' in Ruby
+  mrb_int n = current_i;
+
+  while (j > 0) {
+    j -= 1;
    mrb_value a = RARRAY_PTR(arys_ary)[j]; // arys[j]
    mrb_check_type(mrb, a, MRB_TT_ARRAY);
    mrb_int b = RARRAY_LEN(a);             // a.size
-    if (b <= 0) {
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot compute product with an empty array");
-    }
    mrb_ary_set(mrb, group, j + 1, RARRAY_PTR(a)[n % b]);
    n /= b;
  }
-  if (n >= RARRAY_LEN(self_ary)) {
-    mrb_raise(mrb, E_INDEX_ERROR, "index out of range");
-  }
  mrb_ary_set(mrb, group, 0, RARRAY_PTR(self_ary)[n]);

  return group;
 }

-static mrb_value
-ary_product_generate(mrb_state *mrb, mrb_value self)
-{
-  mrb_value arys_ary, block;
-  mrb_get_args(mrb, "A&", &arys_ary, &block);
-
-  mrb_int total = RARRAY_LEN(self);
-  for (mrb_int i = 0; i < RARRAY_LEN(arys_ary); i++) {
-    mrb_value a = RARRAY_PTR(arys_ary)[i];
-    mrb_check_type(mrb, a, MRB_TT_ARRAY);
-    mrb_int n = RARRAY_LEN(a);
-    if (n == 0) {
-      total = 0;
-      break;
-    }
-    if (mrb_int_mul_overflow(total, n, &total)) {
-      mrb_raise(mrb, E_ARGUMENT_ERROR, "result too big");
-    }
-  }
-
-  if (mrb_nil_p(block)) {
-    mrb_value result = mrb_ary_new_capa(mrb, total);
-    for (mrb_int i = 0; i < total; i++) {
-      mrb_value group = ary_product_fetch(mrb, self, arys_ary, i);
-      mrb_ary_push(mrb, result, group);
-    }
-    return result;
-  }
-  else if (total > 0) {
-    struct RData *d;
-    struct ary_product_generator *g;
-    Data_Make_Struct(mrb, mrb->object_class, struct ary_product_generator,
-                     &ary_product_generator_type, g, d);
-    g->total = total;
-    g->cursor = 0;
-    return mrb_obj_value(d);
-  }
-  else {
-    return mrb_nil_value();
-  }
-}
-
-static mrb_value
-ary_product_next(mrb_state *mrb, mrb_value self)
-{
-  mrb_value arys;
-  struct ary_product_generator *g;
-  mrb_get_args(mrb, "Ad", &arys, &g, &ary_product_generator_type);
-
-  if (g->cursor >= g->total) {
-    return mrb_nil_value();
-  }
-
-  return ary_product_fetch(mrb, self, arys, g->cursor++);
-}
-
 /*
 *  call-seq:
 *     ary.deconstruct -> ary
@@ -1668,8 +1563,7 @@ static const mrb_mt_entry array_ext_rom_entries[] = {
  MRB_MT_ENTRY(ary_fetch,              MRB_SYM(__fetch),            MRB_ARGS_REQ(3)),
  MRB_MT_ENTRY(ary_insert,             MRB_SYM(insert),             MRB_ARGS_ARG(1,-1)),
  MRB_MT_ENTRY(ary_deconstruct,        MRB_SYM(deconstruct),        MRB_ARGS_NONE()),
-  MRB_MT_ENTRY(ary_product_generate,   MRB_SYM(__product_generate), MRB_ARGS_REQ(1)),
-  MRB_MT_ENTRY(ary_product_next,       MRB_SYM(__product_next),     MRB_ARGS_REQ(2)),
+  MRB_MT_ENTRY(ary_product_group,      MRB_SYM(__product_group),    MRB_ARGS_REQ(3)),
  MRB_MT_ENTRY(ary_combination_init,   MRB_SYM(__combination_init), MRB_ARGS_REQ(2)),
  MRB_MT_ENTRY(ary_combination_next,   MRB_SYM(__combination_next), MRB_ARGS_REQ(1)),
 };
@@ -3175,12 +3175,8 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
 {
  if (val) {
    int array_size = 0;
-    int first = 1;
-    int slimit = GEN_LIT_ARY_MAX;
    node *current = tree;

-    if (cursp() >= slimit) slimit = GEN_VAL_STACK_MAX;
-
    /* Process each segment separated by NODE_LITERAL_DELIM */
    while (current) {
      /* Find the segment boundaries without allocating */
@@ -3217,24 +3213,6 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)

        /* Only process non-empty segments */
        if (!is_empty_segment) {
-          /* Flush accumulated elements when stack is full */
-          if (cursp() >= slimit) {
-            if (array_size > 0) {
-              pop_n(array_size);
-              if (first) {
-                genop_2(s, OP_ARRAY, cursp(), array_size);
-                push();
-                first = 0;
-              }
-              else {
-                pop();
-                genop_2(s, OP_ARYPUSH, cursp(), array_size);
-                push();
-              }
-              array_size = 0;
-            }
-          }
-
          /* Temporarily terminate the segment by saving and clearing the cdr */
          node *saved_cdr = NULL;
          if (segment_prev) {
@@ -3265,14 +3243,8 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
      }
    }

-    /* Handle remaining elements */
-    if (!first) {
-      if (array_size > 0) {
-        pop_n(array_size + 1);
-        genop_2(s, OP_ARYPUSH, cursp(), array_size);
-      }
-    }
-    else if (array_size > 0) {
+    /* Generate the array from pushed elements */
+    if (array_size > 0) {
      pop_n(array_size);
      genop_2(s, OP_ARRAY, cursp(), array_size);
    }
@@ -4455,9 +4427,10 @@ codegen_case_match(codegen_scope *s, node *varnode, int val)
    current_in = current_in->cdr;
  }

-  /* No pattern matched - raise NoMatchingPatternError */
-  genop_1(s, OP_LOADFALSE, cursp());
-  genop_1(s, OP_MATCHERR, cursp());
+  /* No pattern matched - generate nil or error */
+  if (val) {
+    genop_1(s, OP_LOADNIL, cursp());
+  }

  /* Dispatch all end jumps */
  if (case_end_jumps != JMPLINK_START) {
@@ -3260,7 +3260,7 @@ primary         : literal
                      $<stack>$ = p->cmdarg_stack;
                      p->cmdarg_stack = 0;
                    }
-                  compstmt {p->lstate = EXPR_ENDARG;} rparen
+                  stmt {p->lstate = EXPR_ENDARG;} rparen
                    {
                      p->cmdarg_stack = $<stack>2;
                      $$ = $3;
@@ -4563,13 +4563,13 @@ f_label         : tIDENTIFIER tLABEL_TAG
                    {
                      $$ = $1;
                      local_nest(p);
-                      p->lstate = EXPR_MID;  /* make newlines significant after label */
+                      p->lstate = EXPR_ARG;  /* make newlines significant after label */
                    }
                | tNUMPARAM tLABEL_TAG
                    {
                      $$ = intern_numparam($1);
                      local_nest(p);
-                      p->lstate = EXPR_MID;  /* make newlines significant after label */
+                      p->lstate = EXPR_ARG;  /* make newlines significant after label */
                    }
                ;

@@ -291,12 +291,11 @@ class Enumerator
    #
    def flat_map(&block)
      Lazy.new(self){|yielder, val|
-        result = block.call(val)
-        if result.respond_to?(:each)
-          result.each {|x| yielder << x }
-        else
-          yielder << result
-        end
+        ary = block.call(val)
+        # TODO: check ary is an Array
+        ary.each {|x|
+          yielder << x
+        }
      }
    end
    alias collect_concat flat_map
@@ -46,18 +46,6 @@ assert("Enumerator::Lazy#to_enum") do
  assert_equal [0*1, 2*3, 4*5, 6*7], lazy_enum.map { |a| a.first * a.last }.first(4)
 end

-assert("Enumerator::Lazy#flat_map with array from block") do
-  assert_equal [1, 10, 2, 20, 3, 30], [1, 2, 3].lazy.flat_map {|x| [x, x*10]}.force
-end
-
-assert("Enumerator::Lazy#flat_map with non-enumerable from block") do
-  assert_equal [1, 2, 3], [1, 2, 3].lazy.flat_map {|x| x}.force
-end
-
-assert("Enumerator::Lazy#flat_map with nested array from block") do
-  assert_equal [[1, 2], [3, 4]], [1, 3].lazy.flat_map {|x| [[x, x+1]]}.force
-end
-
 assert("Enumerator::Lazy#grep_v") do
  lazy_grep_v = (0..).lazy.grep_v(2..4)
  assert_kind_of Enumerator::Lazy, lazy_grep_v
@@ -190,7 +190,11 @@ int_powm(mrb_state *mrb, mrb_value x)
    return mrb_int_pow(mrb, x, mrb_get_arg1(mrb));
  }
  mrb_get_args(mrb, "oo", &e, &m);
-  if (!mrb_integer_p(e) && !mrb_bigint_p(e)) {
+  if (!mrb_integer_p(e)
+#ifdef MRB_USE_BIGINT
+      && !mrb_bigint_p(e)
+#endif
+      ) {
    mrb_raise(mrb, E_TYPE_ERROR, "int.pow(n,m): 2nd argument not allowed unless 1st argument is an integer");
  }
 #ifdef MRB_USE_BIGINT
@@ -19,11 +19,9 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
  file assert_c => [assert_rb, build.mrbcfile] do |t|
    _pp "GEN", t.name.relative_path
    mkdir_p File.dirname(t.name)
-    tmpfile = t.name + ".tmp"
-    open(tmpfile, 'w') do |f|
+    open(t.name, 'w') do |f|
      mrbc.run f, assert_rb, 'mrbtest_assert_irep', cdump: false
    end
-    File.rename(tmpfile, t.name)
  end

  gem_table = build.gems.generate_gem_table build
@@ -38,8 +36,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
    file g.test_rbireps => [g.test_rbfiles, build.mrbcfile].flatten do |t|
      _pp "GEN", t.name.relative_path
      mkdir_p File.dirname(t.name)
-      tmpfile = t.name + ".tmp"
-      open(tmpfile, 'w') do |f|
+      open(t.name, 'w') do |f|
        g.print_gem_test_header(f)
        test_preload = g.test_preload and [g.dir, MRUBY_ROOT].map {|dir|
          File.expand_path(g.test_preload, dir)
@@ -120,7 +117,6 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
        end
        f.puts %Q[}]
      end
-      File.rename(tmpfile, t.name)
    end
  end

@@ -138,8 +134,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
  file clib => ["#{build.build_dir}/mrbgems/active_gems.txt", build.mrbcfile, __FILE__] do |_t|
    _pp "GEN", clib.relative_path
    mkdir_p File.dirname(clib)
-    tmpfile = clib + ".tmp"
-    open(tmpfile, 'w') do |f|
+    open(clib, 'w') do |f|
      f.puts %Q[/*]
      f.puts %Q[ * This file contains a list of all]
      f.puts %Q[ * test functions.]
@@ -174,6 +169,5 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
      end
      f.puts %Q[}]
    end
-    File.rename(tmpfile, clib)
  end
 end
@@ -2748,7 +2748,7 @@ prepare_writer_name(mrb_state *mrb, mrb_sym sym)
 }

 static mrb_value
-mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_int aargc, mrb_value (*accessor)(mrb_state*, mrb_value), mrb_sym (*access_name)(mrb_state*, mrb_sym))
+mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_value (*accessor)(mrb_state*, mrb_value), mrb_sym (*access_name)(mrb_state*, mrb_sym))
 {
  struct RClass *c = mrb_class_ptr(mod);
  const mrb_value *argv;
@@ -2765,7 +2765,6 @@ mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_int aargc, mrb_value (*access
    }

    struct RProc *p = mrb_proc_new_cfunc_with_env(mrb, accessor, 1, &name);
-    p->flags |= aargc == 0 ? MRB_PROC_NOARG : 0;
    mrb_method_t m;
    MRB_METHOD_FROM_PROC(m, p);
    mrb_define_method_raw(mrb, c, method, m);
@@ -2784,7 +2783,7 @@ attr_reader(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_mod_attr_reader(mrb_state *mrb, mrb_value mod)
 {
-  return mod_attr_define(mrb, mod, 0, attr_reader, NULL);
+  return mod_attr_define(mrb, mod, attr_reader, NULL);
 }

 static mrb_value
@@ -2800,7 +2799,7 @@ attr_writer(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_mod_attr_writer(mrb_state *mrb, mrb_value mod)
 {
-  return mod_attr_define(mrb, mod, 1, attr_writer, prepare_writer_name);
+  return mod_attr_define(mrb, mod, attr_writer, prepare_writer_name);
 }

 static mrb_value
@@ -541,15 +541,15 @@ mrb_gc_unregister(mrb_state *mrb, mrb_value obj)
  if (!mrb_array_p(table)) return;
  struct RArray *a = mrb_ary_ptr(table);
  mrb_ary_modify(mrb, a);
-  mrb_int len = ARY_LEN(a);
+  mrb_int len = ARY_LEN(a)-1;
  mrb_value *ptr = ARY_PTR(a);
-  mrb_int w = 0;
-  for (mrb_int r = 0; r < len; r++) {
-    if (mrb_ptr(ptr[r]) != mrb_ptr(obj)) {
-      ptr[w++] = ptr[r];
+  for (mrb_int i = 0; i <= len; i++) {
+    if (mrb_ptr(ptr[i]) == mrb_ptr(obj)) {
+      ARY_SET_LEN(a, len);
+      memmove(&ptr[i], &ptr[i + 1], (len - i) * sizeof(mrb_value));
+      break;
    }
  }
-  ARY_SET_LEN(a, w);
 }

 MRB_API struct RBasic*
@@ -432,7 +432,11 @@ mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, con
  for (mrb_int i = 0; i < argc; i++) {
    mrb_value v = argv[i];

-    if (mrb_integer_p(v) || mrb_bigint_p(v)) {
+    if (mrb_integer_p(v)
+#ifdef MRB_USE_BIGINT
+        || mrb_bigint_p(v)
+#endif
+        ) {
      mrb_int i = mrb_as_int(mrb, v);
      mrb_ary_push(mrb, result, func(mrb, obj, i));
    }
@@ -2703,10 +2703,11 @@ RETRY_TRY_BLOCK:
      if (kidx < 0 || !mrb_hash_p(kdict=regs[kidx]) || !mrb_hash_key_p(mrb, kdict, k)) {
        RAISE_FORMAT(mrb, E_ARGUMENT_ERROR, "missing keyword: %v", k);
      }
-
-      v = mrb_hash_delete_key(mrb, kdict, k);
+      v = mrb_hash_get(mrb, kdict, k);
      ci = mrb->c->ci;
      regs[a] = v;
+      mrb_hash_delete_key(mrb, kdict, k);
+      ci = mrb->c->ci;
      NEXT;
    }

@@ -3112,9 +3113,7 @@ RETRY_TRY_BLOCK:
      {                                                                     \
        mrb_value arg = mrb_int_value(mrb, c);                              \
        mrb_sym mid = MRB_OPSYM(op_name);                                   \
-        mrb_value v = mrb_funcall_argv(mrb, regs[a], mid, 1, &arg);         \
-        ci = mrb->c->ci;                                                    \
-        regs[a] = v;                                                        \
+        regs[a] = mrb_funcall_argv(mrb, regs[a], mid, 1, &arg);             \
        mrb_gc_arena_restore(mrb, ai);                                      \
      }                                                                     \
      break;                                                                \
@@ -29,7 +29,7 @@ MRuby.each_target do |build|
    end
  end

-  presym_task = file presym.list_path => ppps do
+  file presym.list_path => ppps do
    presyms = presym.scan(ppps)
    current_presyms = presym.read_list if File.exist?(presym.list_path)
    if presyms != current_presyms
@@ -41,21 +41,6 @@ MRuby.each_target do |build|
    end
  end

-  # Don't directly write dependency tasks in the "task" arguments.
-  # The rake system tracks dependencies recursively
-  # (see Rake::Task#all_prerequisite_tasks and #collect_prerequisites).
-  # Therefore, indirect dependencies from ".o" to ".pi" must be eliminated.
-  # ref. https://github.com/mruby/mruby/issues/6721
-  # This task acts a proxy-like for the "presym.list_path" task.
-  presym_proxy = task "gensym:update:#{build.name}" do
-    presym_task.invoke
-  end
-
-  # Override the "timestamp" method to reflect the presym file.
-  presym_proxy.define_singleton_method :timestamp do
-    presym_task.timestamp
-  end
-
  # Ensure .o files depend on presym headers being generated.
  # This is critical when a build's .o files are compiled during another
  # build's presym scanning chain (before :gensym completes), e.g.:
@@ -65,7 +50,7 @@ MRuby.each_target do |build|
    next unless File.extname(prereq) == build.exts.object
    next unless prereq.start_with?(build_dir)
    next if mrbc_build_dir && prereq.start_with?(mrbc_build_dir)
-    file prereq => presym_proxy
+    file prereq => presym.list_path
  end

  task gensym: presym.list_path
@@ -163,9 +163,6 @@ assert('Module#attr_reader', '15.2.2.4.13') do

  AttrTestReader.cattr_val = 'test'
  assert_equal 'test', AttrTestReader.cattr
-
-  assert_raise(ArgumentError) { attr_instance.iattr(1) }
-  assert_raise(ArgumentError) { attr_instance.iattr(1, 2, 3) }
 end

 assert('Module#attr_writer', '15.2.2.4.14') do
@@ -680,20 +680,6 @@ assert 'keyword arguments' do
  assert_equal [{a: 1}, {b: 2}], m({a: 1}, b: 2)
  assert_raise(ArgumentError) { m({a: 1}, {b: 2}) }

-  def m1(a: {}) a end
-  assert_equal({}, m1)
-  assert_equal(:abc, m1(a: :abc))
-
-  def m2(a: +1) a end
-  assert_equal(1, m2)
-
-  assert_nothing_raised do
-    def m3 arg:
-      123
-    end
-  end
-  assert_equal(123, m3(arg: 456))
-
  def m(*, a:) a end
  assert_equal 1, m(a: 1)
  assert_equal 3, m(1, 2, a: 3)
@@ -1260,13 +1246,12 @@ assert('pattern matching - NoMatchingPatternError') do
    assert_true e.message.is_a?(String)
  end

-  # case/in without else raises NoMatchingPatternError
-  assert_raise(NoMatchingPatternError) do
-    case 5
-    in 1 then :one
-    in 2 then :two
-    end
+  # case/in without else returns nil (no match)
+  result = case 5
+  in 1 then :one
+  in 2 then :two
  end
+  assert_nil result
 end

 assert('pattern matching - complex patterns') do