diff --git a/CURRENT_TASK.md b/CURRENT_TASK.md index 04e75e6b..c8ff0222 100644 --- a/CURRENT_TASK.md +++ b/CURRENT_TASK.md @@ -77,6 +77,50 @@ Rust は「足場＋Ring0＋テストハーネス」、言語本体の SSOT は --- +## 🎉 Phase 134-B: StringBox bridge 分離（完了）✅ 2025-12-04 + +### 📋 実装内容 + +**目的**: StringBox メソッド処理を boxcall.py から分離し、専用モジュールに集約 + +**背景**: +- Phase 133 で ConsoleBox 箱化パターン確立 +- Phase 134-A で mir_call.py unified 設計完成 +- Phase 134-B で StringBox 箱化により **37.8% 削減達成** + +### 🔧 修正ファイル + +| ファイル | 修正内容 | 重要度 | 行数 | +|---------|---------|-------|------| +| `src/llvm_py/instructions/stringbox.py` | StringBoxBridge 箱（新規） | ⭐⭐⭐ | +466行 | +| `src/llvm_py/instructions/boxcall.py` | StringBox 処理を箱に委譲 | ⭐⭐⭐ | 481→299行 (-182行) | +| `docs/development/current/main/phase134b_stringbox_bridge.md` | 実装ドキュメント更新 | ⭐⭐ | +97行 | + +### 💡 技術的解決策 + +**StringBox メソッド処理の統合**: +- length/len (90行), substring (51行), lastIndexOf (39行) を stringbox.py に集約 +- NYASH_LLVM_FAST 最適化パス: literal folding, length_cache, string_ptrs +- NYASH_STR_CP モード: Code point vs UTF-8 byte 切り替え +- Handle-based / Pointer-based 両パス対応 + +**Phase 133 パターン継承**: +- ConsoleLlvmBridge と同じ箱化モジュール設計 +- emit_stringbox_call() による統一エントリーポイント +- Diagnostic helpers: get_stringbox_method_info() + +### 🎯 成果 +- **boxcall.py 削減**: 481 → 299行 (**37.8% 削減**) +- **StringBox 処理一元化**: 全メソッド処理を stringbox.py に集約 +- **拡張性向上**: Phase 134-C CollectionBox 分離の準備完了 + +### 📌 次のステップ +**Phase 134-C: CollectionBox bridge 分離** +- Array/Map メソッド処理 (get, push, set, has) を分離 +- Phase 133/134-B パターンを継承 + +--- + ## 🎉 Phase 133: ConsoleBox LLVM 統合 & JoinIR→LLVM 第3章完全クローズ（完了）✅ 2025-12-04 ### 📋 実装内容 diff --git a/docs/development/current/main/phase134b_stringbox_bridge.md b/docs/development/current/main/phase134b_stringbox_bridge.md index 17981a97..a2a0447e 100644 --- a/docs/development/current/main/phase134b_stringbox_bridge.md +++ b/docs/development/current/main/phase134b_stringbox_bridge.md @@ -408,6 +408,92 @@ class StringBoxBridge: - ✅ Phase 130-133: JoinIR → LLVM 第3章完全クローズ - ✅ Phase 134-A: mir_call.py unified 設計完成 -- 🎯 Phase 134-B: StringBox bridge 分離（← **現在のフェーズ**） +- ✅ Phase 134-B: StringBox bridge 分離（← **完了！**） - 📋 Phase 134-C: CollectionBox bridge 分離（予定） - 📋 Phase 135: LLVM フラグカタログ化（予定） + +--- + +## Phase 134-B 実装結果 ✅ + +### 実装日時 +2025-12-04 (Claude Code 実装) + +### 修正ファイル +1. **新規作成**: `src/llvm_py/instructions/stringbox.py` (466行) + - StringBoxBridge 箱化モジュール + - length/len, substring, lastIndexOf メソッド lowering 実装 + - 最適化パス統合 (NYASH_LLVM_FAST, NYASH_STR_CP) + - literal folding, length_cache 等の高度な最適化実装 + +2. **修正**: `src/llvm_py/instructions/boxcall.py` (481 → 299行) + - StringBox メソッド処理 (lines 130-323, ~180行) を削除 + - 1行の委譲呼び出しに置き換え: `emit_stringbox_call()` + - import 追加: `from instructions.stringbox import emit_stringbox_call` + +### 実装内容詳細 + +#### StringBoxBridge モジュール構造 +```python +class StringBoxBridge: + STRINGBOX_METHODS = { + "length": 410, + "len": 410, # Alias + "substring": 411, + "lastIndexOf": 412, + } + + # Main dispatcher + emit_stringbox_call() # 全 StringBox メソッドの entry point + + # Method-specific handlers + _emit_length() # length/len 処理 (literal folding, cache, fast path) + _emit_substring() # substring 処理 (NYASH_STR_CP mode) + _emit_lastindexof() # lastIndexOf 処理 + + # Helper functions + _literal_fold_length() # Compile-time length 計算 + _fast_strlen() # NYASH_LLVM_FAST 最適化パス + _codepoint_mode() # NYASH_STR_CP フラグ判定 + get_stringbox_method_info() # Diagnostic helper +``` + +#### 最適化パス統合 +1. **NYASH_LLVM_FAST パス**: + - literal folding: `"hello".length()` → `5` (compile-time) + - length_cache: 計算済み長さをキャッシュ + - string_ptrs: ポインター直接アクセスで高速化 + - newbox_string_args: StringBox 生成時の引数追跡 + +2. **NYASH_STR_CP パス**: + - Code point mode vs UTF-8 byte mode 切り替え + - substring, length 計算でモード考慮 + +3. **Handle-based vs Pointer-based パス**: + - i64 handle: nyash.string.*_hii 系関数 + - i8* pointer: nyash.string.*_sii 系関数 + +### テスト結果 +- ✅ Python import テスト: PASS + - `from instructions.stringbox import emit_stringbox_call` 成功 + - `from instructions.boxcall import lower_boxcall` 成功 +- ✅ 既存テスト: 変更前と同じ結果 (47 failed は pre-existing, VM関連) +- ✅ LLVM backend: インポートエラーなし、構文エラーなし + +### 成果 +- **boxcall.py 削減**: 481 → 299行 (**37.8% 削減, 182行減**) +- **StringBox 処理の一元化**: 全メソッド処理が stringbox.py に集約 +- **Phase 133 パターン継承**: ConsoleLlvmBridge と同じ設計 +- **拡張性向上**: Phase 134-C CollectionBox 分離の準備完了 + +### 設計原則の踏襲 +- ✅ Phase 133 ConsoleLlvmBridge パターンを完全継承 +- ✅ 箱化モジュール化: 1 Box type = 1 dedicated module +- ✅ 最適化パスの統合: 環境変数フラグを module 内で管理 +- ✅ Diagnostic helpers: get_stringbox_method_info() 実装 + +### 次のステップ +**Phase 134-C: CollectionBox bridge 分離** +- boxcall.py:143-193 の Array/Map メソッド処理を分離 +- get, push, set, has メソッドを collectionbox.py に集約 +- Phase 133/134-B パターンを継承 diff --git a/src/llvm_py/instructions/boxcall.py b/src/llvm_py/instructions/boxcall.py index ad9cff09..36c46566 100644 --- a/src/llvm_py/instructions/boxcall.py +++ b/src/llvm_py/instructions/boxcall.py @@ -8,6 +8,7 @@ from typing import Dict, List, Optional, Any from instructions.safepoint import insert_automatic_safepoint from naming_helper import encode_static_method from console_bridge import emit_console_call # Phase 133: Console 箱化モジュール +from instructions.stringbox import emit_stringbox_call # Phase 134-B: StringBox 箱化モジュール def _declare(module: ir.Module, name: str, ret, args): for f in module.functions: @@ -126,97 +127,8 @@ def lower_boxcall( if recv_val is None: recv_val = vmap.get(box_vid, ir.Constant(i64, 0)) - # Minimal method bridging for strings and console - if method_name in ("length", "len"): - # Fast path (opt-in): pointer-based string length → nyash.string.length_si(i8*, i64 mode) - try: - import os - fast_on = os.environ.get('NYASH_LLVM_FAST') == '1' - except Exception: - fast_on = False - def _cache_len(val): - if not fast_on or resolver is None or dst_vid is None or box_vid is None: - return - cache = getattr(resolver, 'length_cache', None) - if cache is None: - return - try: - cache[int(box_vid)] = val - except Exception: - pass - if fast_on and resolver is not None and dst_vid is not None and box_vid is not None: - cache = getattr(resolver, 'length_cache', None) - if cache is not None: - try: - cached = cache.get(int(box_vid)) - except Exception: - cached = None - if cached is not None: - vmap[dst_vid] = cached - return - # Ultra-fast: literal length folding when receiver originates from a string literal. - # Check resolver.newbox_string_args[recv] -> arg_vid -> resolver.string_literals[arg_vid] - if fast_on and dst_vid is not None and resolver is not None: - try: - arg_vid = None - if hasattr(resolver, 'newbox_string_args'): - arg_vid = resolver.newbox_string_args.get(int(box_vid)) - # Case A: newbox(StringBox, const) - if arg_vid is not None and hasattr(resolver, 'string_literals'): - lit = resolver.string_literals.get(int(arg_vid)) - if isinstance(lit, str): - # Mode: bytes or code points - use_cp = os.environ.get('NYASH_STR_CP') == '1' - n = len(lit) if use_cp else len(lit.encode('utf-8')) - const_len = ir.Constant(ir.IntType(64), n) - vmap[dst_vid] = const_len - _cache_len(const_len) - return - # Case B: receiver itself is a literal-backed handle (const string) - if hasattr(resolver, 'string_literals'): - lit2 = resolver.string_literals.get(int(box_vid)) - if isinstance(lit2, str): - use_cp = os.environ.get('NYASH_STR_CP') == '1' - n2 = len(lit2) if use_cp else len(lit2.encode('utf-8')) - const_len2 = ir.Constant(ir.IntType(64), n2) - vmap[dst_vid] = const_len2 - _cache_len(const_len2) - return - except Exception: - pass - if fast_on and resolver is not None and hasattr(resolver, 'string_ptrs'): - try: - ptr = resolver.string_ptrs.get(int(box_vid)) - except Exception: - ptr = None - - # Fallback: If not found, check if receiver came from newbox(StringBox) with const string arg - # This handles AOT/EXE scenarios where StringBox plugin isn't loaded - if ptr is None and hasattr(resolver, 'newbox_string_args'): - try: - # Check if box_vid is a result of newbox(StringBox, [string_vid]) - arg_vid = resolver.newbox_string_args.get(int(box_vid)) - if arg_vid is not None: - # Try to get the string ptr from the argument - ptr = resolver.string_ptrs.get(int(arg_vid)) - except Exception: - pass - - if ptr is not None: - mode = 1 if os.environ.get('NYASH_STR_CP') == '1' else 0 - mode_c = ir.Constant(i64, mode) - # Prefer neutral kernel symbol; legacy name kept in NyRT for compatibility - callee = _declare(module, "nyrt_string_length", i64, [i8p, i64]) - result = builder.call(callee, [ptr, mode_c], name="strlen_si") - if dst_vid is not None: - vmap[dst_vid] = result - return - # Default: Any.length_h(handle) → i64 - recv_h = _ensure_handle(builder, module, recv_val) - callee = _declare(module, "nyash.any.length_h", i64, [i64]) - result = builder.call(callee, [recv_h], name="any_length_h") - if dst_vid is not None: - vmap[dst_vid] = result + # Phase 134-B: StringBox 箱化 - StringBox メソッドを stringbox に委譲 + if emit_stringbox_call(builder, module, method_name, recv_val, args, dst_vid, vmap, box_vid, resolver, preds, block_end_values, bb_map, ctx): return if method_name == "size": @@ -228,100 +140,6 @@ def lower_boxcall( vmap[dst_vid] = result return - if method_name == "substring": - # substring(start, end) - # If receiver is a handle (i64), use handle-based helper; else pointer-based API - s = _res_i64(args[0]) if args else ir.Constant(i64, 0) - if s is None: - s = vmap.get(args[0], ir.Constant(i64, 0)) if args else ir.Constant(i64, 0) - e = _res_i64(args[1]) if len(args) > 1 else ir.Constant(i64, 0) - if e is None: - e = vmap.get(args[1], ir.Constant(i64, 0)) if len(args) > 1 else ir.Constant(i64, 0) - if hasattr(recv_val, 'type') and isinstance(recv_val.type, ir.IntType): - # handle-based - callee = _declare(module, "nyash.string.substring_hii", i64, [i64, i64, i64]) - h = builder.call(callee, [recv_val, s, e], name="substring_h") - if dst_vid is not None: - vmap[dst_vid] = h - try: - if resolver is not None and hasattr(resolver, 'mark_string'): - resolver.mark_string(dst_vid) - except Exception: - pass - return - else: - # pointer-based - recv_p = recv_val - if hasattr(recv_p, 'type') and isinstance(recv_p.type, ir.PointerType): - try: - if isinstance(recv_p.type.pointee, ir.ArrayType): - c0 = ir.Constant(ir.IntType(32), 0) - recv_p = builder.gep(recv_p, [c0, c0], name="bc_gep_recv") - except Exception: - pass - else: - recv_p = ir.Constant(i8p, None) - # Coerce indices - if hasattr(s, 'type') and isinstance(s.type, ir.PointerType): - s = builder.ptrtoint(s, i64) - if hasattr(e, 'type') and isinstance(e.type, ir.PointerType): - e = builder.ptrtoint(e, i64) - callee = _declare(module, "nyash.string.substring_sii", i8p, [i8p, i64, i64]) - p = builder.call(callee, [recv_p, s, e], name="substring") - conv = _declare(module, "nyash.box.from_i8_string", i64, [i8p]) - h = builder.call(conv, [p], name="str_ptr2h_sub") - if dst_vid is not None: - vmap[dst_vid] = h - try: - if resolver is not None and hasattr(resolver, 'mark_string'): - resolver.mark_string(dst_vid) - if resolver is not None and hasattr(resolver, 'string_ptrs'): - resolver.string_ptrs[int(dst_vid)] = p - except Exception: - pass - return - - if method_name == "lastIndexOf": - # lastIndexOf(needle) - if resolver is not None and preds is not None and block_end_values is not None and bb_map is not None: - n_i64 = resolver.resolve_i64(args[0], builder.block, preds, block_end_values, vmap, bb_map) if args else ir.Constant(i64, 0) - else: - n_i64 = vmap.get(args[0], ir.Constant(i64, 0)) if args else ir.Constant(i64, 0) - if hasattr(recv_val, 'type') and isinstance(recv_val.type, ir.IntType): - # handle-based - callee = _declare(module, "nyash.string.lastIndexOf_hh", i64, [i64, i64]) - res = builder.call(callee, [recv_val, n_i64], name="lastIndexOf_hh") - if dst_vid is not None: - vmap[dst_vid] = res - return - else: - # pointer-based - recv_p = recv_val - if hasattr(recv_p, 'type') and isinstance(recv_p.type, ir.PointerType): - try: - if isinstance(recv_p.type.pointee, ir.ArrayType): - c0 = ir.Constant(ir.IntType(32), 0) - recv_p = builder.gep(recv_p, [c0, c0], name="bc_gep_recv2") - except Exception: - pass - else: - recv_p = ir.Constant(i8p, None) - needle = n_i64 - if hasattr(needle, 'type') and isinstance(needle.type, ir.IntType): - needle = builder.inttoptr(needle, i8p, name="bc_i2p_needle") - elif hasattr(needle, 'type') and isinstance(needle.type, ir.PointerType): - try: - if isinstance(needle.type.pointee, ir.ArrayType): - c0 = ir.Constant(ir.IntType(32), 0) - needle = builder.gep(needle, [c0, c0], name="bc_gep_needle") - except Exception: - pass - callee = _declare(module, "nyash.string.lastIndexOf_ss", i64, [i8p, i8p]) - res = builder.call(callee, [recv_p, needle], name="lastIndexOf") - if dst_vid is not None: - vmap[dst_vid] = res - return - if method_name == "get": # ArrayBox.get(index) → nyash.array.get_h(handle, idx) # MapBox.get(key) → nyash.map.get_hh(handle, key_any) diff --git a/src/llvm_py/instructions/stringbox.py b/src/llvm_py/instructions/stringbox.py new file mode 100644 index 00000000..3d28e048 --- /dev/null +++ b/src/llvm_py/instructions/stringbox.py @@ -0,0 +1,466 @@ +""" +Phase 134-B: StringBox LLVM Bridge - StringBox 統合モジュール + +目的: +- StringBox メソッド (length/len/substring/lastIndexOf) の LLVM IR 変換を1箇所に集約 +- BoxCall lowering 側の分岐を削除し、箱化モジュール化を実現 + +設計原則: +- Phase 133 ConsoleLlvmBridge パターンを継承 +- 複雑な最適化パス (NYASH_LLVM_FAST, NYASH_STR_CP) を統合 +- literal folding, length_cache 等の高度な最適化を含む +""" + +import llvmlite.ir as ir +from typing import Dict, List, Optional, Any +import os + + +# StringBox method mapping (TypeRegistry slots 410-412) +STRINGBOX_METHODS = { + "length": 410, + "len": 410, # Alias for length + "substring": 411, + "lastIndexOf": 412, +} + + +def _declare(module: ir.Module, name: str, ret, args): + """Declare or get existing function""" + for f in module.functions: + if f.name == name: + return f + fnty = ir.FunctionType(ret, args) + return ir.Function(module, fnty, name=name) + + +def _ensure_handle(builder: ir.IRBuilder, module: ir.Module, v: ir.Value) -> ir.Value: + """Coerce a value to i64 handle. If pointer, box via nyash.box.from_i8_string.""" + i64 = ir.IntType(64) + if hasattr(v, 'type'): + if isinstance(v.type, ir.IntType) and v.type.width == 64: + return v + if isinstance(v.type, ir.PointerType): + # call nyash.box.from_i8_string(i8*) -> i64 + i8p = ir.IntType(8).as_pointer() + # If pointer-to-array, GEP to first element + try: + if isinstance(v.type.pointee, ir.ArrayType): + c0 = ir.IntType(32)(0) + v = builder.gep(v, [c0, c0], name="sb_str_gep") + except Exception: + pass + callee = _declare(module, "nyash.box.from_i8_string", i64, [i8p]) + return builder.call(callee, [v], name="str_ptr2h_sb") + if isinstance(v.type, ir.IntType): + # extend/trunc to i64 + return builder.zext(v, i64) if v.type.width < 64 else builder.trunc(v, i64) + return ir.Constant(i64, 0) + + +def emit_stringbox_call( + builder: ir.IRBuilder, + module: ir.Module, + method_name: str, + recv_val: ir.Value, + args: List[int], + dst_vid: Optional[int], + vmap: Dict[int, ir.Value], + box_vid: int, + resolver=None, + preds=None, + block_end_values=None, + bb_map=None, + ctx: Optional[Any] = None, +) -> bool: + """ + Emit StringBox method call to LLVM IR. + + Returns: + True if method was handled, False if not a StringBox method + + Args: + builder: LLVM IR builder + module: LLVM module + method_name: StringBox method name (length/len/substring/lastIndexOf) + recv_val: Receiver value (StringBox instance) + args: Argument value IDs + dst_vid: Destination value ID + vmap: Value map + box_vid: Box value ID + resolver: Optional type resolver + preds: Predecessor map + block_end_values: Block end values + bb_map: Basic block map + ctx: Build context + """ + # Check if this is a StringBox method + if method_name not in STRINGBOX_METHODS: + return False + + i64 = ir.IntType(64) + + # Extract resolver/preds from ctx if available + r = resolver + p = preds + bev = block_end_values + bbm = bb_map + if ctx is not None: + try: + r = getattr(ctx, 'resolver', r) + p = getattr(ctx, 'preds', p) + bev = getattr(ctx, 'block_end_values', bev) + bbm = getattr(ctx, 'bb_map', bbm) + except Exception: + pass + + def _res_i64(vid: int): + """Resolve value ID to i64 via resolver or vmap""" + if r is not None and p is not None and bev is not None and bbm is not None: + try: + return r.resolve_i64(vid, builder.block, p, bev, vmap, bbm) + except Exception: + return None + return vmap.get(vid) + + # Dispatch to method-specific handlers + if method_name in ("length", "len"): + return _emit_length( + builder, module, recv_val, args, dst_vid, vmap, box_vid, r, p, bev, bbm + ) + elif method_name == "substring": + return _emit_substring( + builder, module, recv_val, args, dst_vid, vmap, r, p, bev, bbm, _res_i64 + ) + elif method_name == "lastIndexOf": + return _emit_lastindexof( + builder, module, recv_val, args, dst_vid, vmap, r, p, bev, bbm, _res_i64 + ) + + return False + + +def _emit_length( + builder: ir.IRBuilder, + module: ir.Module, + recv_val: ir.Value, + args: List[int], + dst_vid: Optional[int], + vmap: Dict[int, ir.Value], + box_vid: int, + resolver, + preds, + block_end_values, + bb_map, +) -> bool: + """ + Emit StringBox.length() / StringBox.len() to LLVM IR. + + Supports: + - NYASH_LLVM_FAST: Fast path optimization + - literal folding: "hello".length() -> 5 + - length_cache: cache computed lengths + """ + i64 = ir.IntType(64) + i8p = ir.IntType(8).as_pointer() + + # Check NYASH_LLVM_FAST flag + fast_on = os.environ.get('NYASH_LLVM_FAST') == '1' + + def _cache_len(val): + if not fast_on or resolver is None or dst_vid is None or box_vid is None: + return + cache = getattr(resolver, 'length_cache', None) + if cache is None: + return + try: + cache[int(box_vid)] = val + except Exception: + pass + + # Fast path: check length_cache + if fast_on and resolver is not None and dst_vid is not None and box_vid is not None: + cache = getattr(resolver, 'length_cache', None) + if cache is not None: + try: + cached = cache.get(int(box_vid)) + except Exception: + cached = None + if cached is not None: + vmap[dst_vid] = cached + return True + + # Ultra-fast: literal length folding + if fast_on and dst_vid is not None and resolver is not None: + try: + lit = None + arg_vid = None + + # Case A: newbox(StringBox, const) + if hasattr(resolver, 'newbox_string_args'): + arg_vid = resolver.newbox_string_args.get(int(box_vid)) + if arg_vid is not None and hasattr(resolver, 'string_literals'): + lit = resolver.string_literals.get(int(arg_vid)) + + # Case B: receiver itself is a literal-backed handle + if lit is None and hasattr(resolver, 'string_literals'): + lit = resolver.string_literals.get(int(box_vid)) + + if isinstance(lit, str): + # Compute length based on mode + use_cp = _codepoint_mode() + n = len(lit) if use_cp else len(lit.encode('utf-8')) + const_len = ir.Constant(i64, n) + vmap[dst_vid] = const_len + _cache_len(const_len) + return True + except Exception: + pass + + # Fast path: use string_ptrs for direct strlen + if fast_on and resolver is not None and hasattr(resolver, 'string_ptrs'): + try: + ptr = resolver.string_ptrs.get(int(box_vid)) + except Exception: + ptr = None + + # Fallback: check newbox_string_args + if ptr is None and hasattr(resolver, 'newbox_string_args'): + try: + arg_vid = resolver.newbox_string_args.get(int(box_vid)) + if arg_vid is not None: + ptr = resolver.string_ptrs.get(int(arg_vid)) + except Exception: + pass + + if ptr is not None: + return _fast_strlen(builder, module, ptr, dst_vid, vmap, _cache_len) + + # Default: Any.length_h(handle) -> i64 + recv_h = _ensure_handle(builder, module, recv_val) + callee = _declare(module, "nyash.any.length_h", i64, [i64]) + result = builder.call(callee, [recv_h], name="any_length_h") + if dst_vid is not None: + vmap[dst_vid] = result + return True + + +def _emit_substring( + builder: ir.IRBuilder, + module: ir.Module, + recv_val: ir.Value, + args: List[int], + dst_vid: Optional[int], + vmap: Dict[int, ir.Value], + resolver, + preds, + block_end_values, + bb_map, + _res_i64, +) -> bool: + """ + Emit StringBox.substring(start, end) to LLVM IR. + + Supports: + - NYASH_STR_CP: Code point vs UTF-8 byte mode + """ + i64 = ir.IntType(64) + i8p = ir.IntType(8).as_pointer() + + # Get start and end indices + s = _res_i64(args[0]) if args else ir.Constant(i64, 0) + if s is None: + s = vmap.get(args[0], ir.Constant(i64, 0)) if args else ir.Constant(i64, 0) + + e = _res_i64(args[1]) if len(args) > 1 else ir.Constant(i64, 0) + if e is None: + e = vmap.get(args[1], ir.Constant(i64, 0)) if len(args) > 1 else ir.Constant(i64, 0) + + # Handle-based path + if hasattr(recv_val, 'type') and isinstance(recv_val.type, ir.IntType): + callee = _declare(module, "nyash.string.substring_hii", i64, [i64, i64, i64]) + h = builder.call(callee, [recv_val, s, e], name="substring_h") + if dst_vid is not None: + vmap[dst_vid] = h + try: + if resolver is not None and hasattr(resolver, 'mark_string'): + resolver.mark_string(dst_vid) + except Exception: + pass + return True + + # Pointer-based path + recv_p = recv_val + if hasattr(recv_p, 'type') and isinstance(recv_p.type, ir.PointerType): + try: + if isinstance(recv_p.type.pointee, ir.ArrayType): + c0 = ir.Constant(ir.IntType(32), 0) + recv_p = builder.gep(recv_p, [c0, c0], name="sb_gep_recv") + except Exception: + pass + else: + recv_p = ir.Constant(i8p, None) + + # Coerce indices + if hasattr(s, 'type') and isinstance(s.type, ir.PointerType): + s = builder.ptrtoint(s, i64) + if hasattr(e, 'type') and isinstance(e.type, ir.PointerType): + e = builder.ptrtoint(e, i64) + + callee = _declare(module, "nyash.string.substring_sii", i8p, [i8p, i64, i64]) + p = builder.call(callee, [recv_p, s, e], name="substring") + conv = _declare(module, "nyash.box.from_i8_string", i64, [i8p]) + h = builder.call(conv, [p], name="str_ptr2h_sub") + + if dst_vid is not None: + vmap[dst_vid] = h + try: + if resolver is not None and hasattr(resolver, 'mark_string'): + resolver.mark_string(dst_vid) + if resolver is not None and hasattr(resolver, 'string_ptrs'): + resolver.string_ptrs[int(dst_vid)] = p + except Exception: + pass + + return True + + +def _emit_lastindexof( + builder: ir.IRBuilder, + module: ir.Module, + recv_val: ir.Value, + args: List[int], + dst_vid: Optional[int], + vmap: Dict[int, ir.Value], + resolver, + preds, + block_end_values, + bb_map, + _res_i64, +) -> bool: + """ + Emit StringBox.lastIndexOf(needle) to LLVM IR. + """ + i64 = ir.IntType(64) + i8p = ir.IntType(8).as_pointer() + + # Get needle argument + n_i64 = _res_i64(args[0]) if args else ir.Constant(i64, 0) + if n_i64 is None: + n_i64 = vmap.get(args[0], ir.Constant(i64, 0)) if args else ir.Constant(i64, 0) + + # Handle-based path + if hasattr(recv_val, 'type') and isinstance(recv_val.type, ir.IntType): + callee = _declare(module, "nyash.string.lastIndexOf_hh", i64, [i64, i64]) + res = builder.call(callee, [recv_val, n_i64], name="lastIndexOf_hh") + if dst_vid is not None: + vmap[dst_vid] = res + return True + + # Pointer-based path + recv_p = recv_val + if hasattr(recv_p, 'type') and isinstance(recv_p.type, ir.PointerType): + try: + if isinstance(recv_p.type.pointee, ir.ArrayType): + c0 = ir.Constant(ir.IntType(32), 0) + recv_p = builder.gep(recv_p, [c0, c0], name="sb_gep_recv2") + except Exception: + pass + else: + recv_p = ir.Constant(i8p, None) + + # Convert needle to pointer + needle = n_i64 + if hasattr(needle, 'type') and isinstance(needle.type, ir.IntType): + needle = builder.inttoptr(needle, i8p, name="sb_i2p_needle") + elif hasattr(needle, 'type') and isinstance(needle.type, ir.PointerType): + try: + if isinstance(needle.type.pointee, ir.ArrayType): + c0 = ir.Constant(ir.IntType(32), 0) + needle = builder.gep(needle, [c0, c0], name="sb_gep_needle") + except Exception: + pass + + callee = _declare(module, "nyash.string.lastIndexOf_ss", i64, [i8p, i8p]) + res = builder.call(callee, [recv_p, needle], name="lastIndexOf") + if dst_vid is not None: + vmap[dst_vid] = res + + return True + + +# Helper functions + +def _literal_fold_length(literal_str: str) -> int: + """ + Compute literal StringBox length at compile-time. + + Example: "hello".length() -> 5 + """ + use_cp = _codepoint_mode() + return len(literal_str) if use_cp else len(literal_str.encode('utf-8')) + + +def _fast_strlen( + builder: ir.IRBuilder, + module: ir.Module, + ptr: ir.Value, + dst_vid: Optional[int], + vmap: Dict[int, ir.Value], + cache_callback, +) -> bool: + """ + NYASH_LLVM_FAST path for optimized strlen implementation. + """ + i64 = ir.IntType(64) + i8p = ir.IntType(8).as_pointer() + + mode = 1 if _codepoint_mode() else 0 + mode_c = ir.Constant(i64, mode) + + # Prefer neutral kernel symbol + callee = _declare(module, "nyrt_string_length", i64, [i8p, i64]) + result = builder.call(callee, [ptr, mode_c], name="strlen_si") + + if dst_vid is not None: + vmap[dst_vid] = result + cache_callback(result) + + return True + + +def _codepoint_mode() -> bool: + """ + Check NYASH_STR_CP flag to determine code point / UTF-8 byte mode. + + Returns: + True if code point mode, False if UTF-8 byte mode + """ + return os.environ.get('NYASH_STR_CP') == '1' + + +# Phase 134-B: Diagnostic helpers + +def get_stringbox_method_info(method_name: str) -> Optional[Dict[str, Any]]: + """ + Get StringBox method metadata for debugging/diagnostics. + + Returns: + Dict with keys: slot, arity, is_alias + None if not a StringBox method + """ + if method_name not in STRINGBOX_METHODS: + return None + + arity_map = { + "length": 0, + "len": 0, + "substring": 2, + "lastIndexOf": 1, + } + + return { + "slot": STRINGBOX_METHODS[method_name], + "arity": arity_map[method_name], + "is_alias": method_name == "len", + }