refactor: string handling and improve diagnostics

- Updated string handling functions to utilize the built-in StringBuilder for better performance and consistency.
- Enhanced the RuntimeLocation enum with a Debug representation.
- Modified various string-related functions to improve code clarity and maintainability.
- Changed diagnostics handling to use lexer reports instead of parser reports.
- Updated package dependencies to newer versions for improved functionality and stability.
- Refactored test cases to align with new function signatures and improve readability.
- Added output and to_string methods for EvalResult, TestFailure, and TestResult for better logging and debugging.

Author: oboard

async/pkg.generated.mbti

@@ -10,4 +10,3 @@ package "oboard/eval/async"
 // Type aliases
 
 // Traits
-

benchmark_test.mbt

@@ -4,7 +4,7 @@
 
 // 表达式求值基准测试
 test "benchmark_arithmetic_expressions" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let code = "1 + 2 * 3 - 4 / 2 + (5 * 6) - 7"
   b.bench(fn() { b.keep(vm.eval(code)) })
 }
@@ -16,14 +16,14 @@ test "native_benchmark_arithmetic_expressions" (b : @bench.T) {
 
 ///|
 test "benchmark_compiled_arithmetic_expressions" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let compiled = vm.compile("1 + 2 * 3 - 4 / 2 + (5 * 6) - 7")
   b.bench(fn() { b.keep(compiled.run(vm)) })
 }
 
 ///|
 test "benchmark_compiled_parameters" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let compiled = vm.compile("a + b * c - d / e + f * g - h", params=[
     "a", "b", "c", "d", "e", "f", "g", "h",
   ])
@@ -34,7 +34,7 @@ test "benchmark_compiled_parameters" (b : @bench.T) {
 
 ///|
 test "benchmark_variable_access" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
 
   // 设置变量
   vm.run("let x = 42; let y = 100; let z = x + y")
@@ -45,7 +45,7 @@ test "benchmark_variable_access" (b : @bench.T) {
 
 ///|
 test "benchmark_function_calls" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let code = "fn add(x, y) { x + y }; fn mul(x, y) { x * y }; fn complex(a, b, c) { add(mul(a, b), c) }; complex(10, 20, 30)"
   b.bench(fn() { b.keep(vm.eval(code)) })
 }
@@ -54,7 +54,7 @@ test "benchmark_function_calls" (b : @bench.T) {
 
 ///|
 test "benchmark_array_operations" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let code = "let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let sum = arr[0] + arr[1] + arr[2] + arr[3] + arr[4]; sum"
   b.bench(fn() { b.keep(vm.eval(code)) })
 }
@@ -63,7 +63,7 @@ test "benchmark_array_operations" (b : @bench.T) {
 
 ///|
 test "benchmark_recursive_functions" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let code = "fn fibonacci(n) { if n <= 1 { n } else { fibonacci(n - 1) + fibonacci(n - 2) } }; fibonacci(10)"
   b.bench(fn() { b.keep(vm.eval(code)) })
 }
@@ -72,7 +72,7 @@ test "benchmark_recursive_functions" (b : @bench.T) {
 
 ///|
 test "benchmark_tail_recursive_fibonacci" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let code = "fn fib_tail(n, a, b) { if n == 0 { a } else { fib_tail(n - 1, b, a + b) } }; fn fibonacci_fast(n) { fib_tail(n, 0, 1) }; fibonacci_fast(10)"
   b.bench(fn() { b.keep(vm.eval(code)) })
 }
@@ -81,7 +81,7 @@ test "benchmark_tail_recursive_fibonacci" (b : @bench.T) {
 
 ///|
 test "benchmark_iterative_fibonacci" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let code = "fn fibonacci_iter(n) { let mut a = 0; let mut b = 1; let mut i = 0; while i < n { let temp = a + b; a = b; b = temp; i = i + 1 }; a }; fibonacci_iter(10)"
   b.bench(fn() { b.keep(vm.eval(code)) })
 }
@@ -90,7 +90,7 @@ test "benchmark_iterative_fibonacci" (b : @bench.T) {
 
 ///|
 test "benchmark_complex_expressions" (b : @bench.T) {
-  let vm = MoonBitVM::new(log=false)
+  let vm = @eval.MoonBitVM::new(log=false)
   let code = "let a = 10; let b = 20; let c = 30; (a + b) * c - (a * b) + (c / 2) - (a - b)"
   b.bench(fn() { b.keep(vm.eval(code)) })
 }

example/moon.pkg

@@ -2,6 +2,4 @@ import {
   "oboard/eval",
 }
 
-options(
-  "is-main": true,
-)
+pkgtype(kind: "executable")

example/pkg.generated.mbti

@@ -10,4 +10,3 @@ package "oboard/eval/example"
 // Type aliases
 
 // Traits
-

export.mbt

@@ -62,8 +62,8 @@ pub fn test_result_to_string(result : TestResult) -> String {
 ///|
 pub fn code_to_ast(code : String) -> String {
   match @core.parse_eval_code(code) {
-    Ok(EvalExpr(expr)) => expr.to_json().stringify()
-    Ok(EvalTop(impls, ..)) => impls.to_json().stringify()
+    Ok(EvalExpr(expr)) => @json.to_json(expr).stringify()
+    Ok(EvalTop(impls, ..)) => @json.to_json(impls).stringify()
     Err(msg) => msg
   }
 }

generate_core_modules.py

@@ -3,48 +3,106 @@
 Generate embedded core modules for moonbit-eval interpreter.
 This script reads all modules from moonbitlang/core and generates
 RuntimePackage definitions in the format expected by core_modules.mbt.
+It honors the `options.targets` directive in each package's moon.pkg
+to include only files relevant for the js target.
 """
 
 import os
+import re
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict, List, Optional, Set, Tuple
 
 # Core library path
 CORE_PATH = "/Users/oboard/.moon/lib/core"
 OUTPUT_FILE = "interpreter/core/core_modules.mbt"
 
-# Removed extract_all_items function - no longer needed with new format
+# Target we are building for
+BUILD_TARGET = "js"
 
-def read_module_info(module_dir: Path) -> Dict:
+def parse_targets(moon_pkg_content: str) -> Dict[str, List[str]]:
+    """Parse options(targets: { ... }) from moon.pkg content.
+    
+    Returns a dict mapping filename -> list of target strings.
+    Files not listed in targets are included for all targets.
     """
-    Read module information from a directory.
-    Returns dict with module name, dependencies, and concatenated code content.
+    targets = {}
+    # Match options(targets: { ... }) block
+    m = re.search(r'targets\s*:\s*\{([^}]*)\}', moon_pkg_content, re.DOTALL)
+    if not m:
+        return targets
+    
+    block = m.group(1)
+    # Parse each entry: "filename": [ "target1", "target2" ]
+    for entry_m in re.finditer(r'"([^"]+)"\s*:\s*\[([^\]]*)\]', block):
+        filename = entry_m.group(1)
+        targets_str = entry_m.group(2)
+        target_list = [t.strip().strip('"') for t in targets_str.split(',') if t.strip().strip('"')]
+        targets[filename] = target_list
+    
+    return targets
+
+def should_include_file(filename: str, targets: Dict[str, List[str]], build_target: str) -> bool:
+    """Determine if a file should be included for the given build target.
+    
+    Rules:
+    - If file is not in targets dict, include for all targets.
+    - If the target list starts with "not", include for targets NOT in the list.
+    - Otherwise, include only for targets IN the list.
     """
+    if filename not in targets:
+        return True
+    
+    target_list = targets[filename]
+    if not target_list:
+        return True
+    
+    if target_list[0] == "not":
+        # Exclude for listed targets
+        return build_target not in target_list[1:]
+    else:
+        # Include only for listed targets
+        return build_target in target_list
+
+def read_module_info(module_dir: Path) -> Optional[Dict]:
+    """Read module information from a directory."""
     pkg = "moonbitlang/core/" + module_dir.relative_to(CORE_PATH).as_posix()
     alias = module_dir.relative_to(CORE_PATH).as_posix()
     module_name = pkg.replace('/', '_')
 
-    # Keep embedded package deps empty to avoid introducing definition cycles.
-    # The generated file is used as a flat registry of embedded packages.
     dependencies = []
 
+    # Read moon.pkg to get targets
+    moon_pkg_path = module_dir / "moon.pkg"
+    file_targets = {}
+    if moon_pkg_path.exists():
+        try:
+            with open(moon_pkg_path, 'r', encoding='utf-8') as f:
+                pkg_content = f.read()
+                file_targets = parse_targets(pkg_content)
+        except (UnicodeDecodeError, FileNotFoundError):
+            pass
+    
     # Find all .mbt files (excluding test files)
     mbt_files = [f for f in module_dir.glob("*.mbt") 
                  if not f.name.endswith('_test.mbt') and not f.name.endswith('_wbtest.mbt')]
 
-    # Collect file contents with their names
+    # Collect file contents with their names, filtering by target
     file_contents = {}
 
-    for mbt_file in sorted(mbt_files):  # Sort for consistent ordering
+    for mbt_file in sorted(mbt_files):
+        if not should_include_file(mbt_file.name, file_targets, BUILD_TARGET):
+            continue
         try:
             with open(mbt_file, 'r', encoding='utf-8') as f:
                 content = f.read().strip()
-                if content:  # Only add non-empty content
+                if content:
                     file_contents[mbt_file.name] = content
         except (UnicodeDecodeError, FileNotFoundError):
             continue
 
-    # Join all content with double newlines for backward compatibility
+    if not file_contents:
+        return None
+    
     concatenated_code = '\n\n'.join(file_contents.values())
 
     return {
@@ -56,19 +114,14 @@ def read_module_info(module_dir: Path) -> Dict:
         'files': file_contents
     }
 
-# Removed has_non_self_parameters function - no longer needed with new format
-
 def generate_module_code(module_info: Dict) -> str:
-    """
-    Generate RuntimePackage code for a single module.
-    """
+    """Generate RuntimePackage code for a single module."""
     pkg = module_info['pkg']
     module_name = module_info['name']
-    code = module_info['code']
     dependencies = module_info['dependencies']
     files = module_info['files']
 
-    if not code.strip():
+    if not files:
         return ""
 
     # Generate dependencies map
@@ -85,22 +138,18 @@ def generate_module_code(module_info: Dict) -> str:
     # Generate files map
     files_map_entries = []
     for filename, content in files.items():
-        # Format the code with #| prefix for each line, filtering out comments and empty lines
         code_lines = content.split('\n')
         formatted_code_lines = []
         for line in code_lines:
-            # Skip comment lines and empty lines to reduce file size
             stripped_line = line.strip()
-            if not stripped_line or stripped_line.startswith('//') or stripped_line.startswith('///') or stripped_line.startswith('///'):
+            if not stripped_line or stripped_line.startswith('//') or stripped_line.startswith('///'):
                 continue
-            # Escape quotes and backslashes for the string literal
             formatted_code_lines.append(f'    #|{line}')
 
         if formatted_code_lines:
             formatted_content = '\n'.join(formatted_code_lines)
             files_map_entries.append(f'  "{filename}": (\n{formatted_content}\n  )')
         else:
-            # For empty files, generate empty string
             files_map_entries.append(f'  "{filename}": ""')
 
     files_map_str = ',\n'.join(files_map_entries)
@@ -117,9 +166,7 @@ def generate_module_code(module_info: Dict) -> str:
     return module_code
 
 def generate_core_modules_map(modules: List[dict]) -> str:
-    """
-    Generate the core_modules map declaration.
-    """
+    """Generate the core_modules map declaration."""
     entries = []
     for module in modules: 
         entries.append(f'"{module["alias"]}": {module["name"]}_module')
@@ -130,19 +177,17 @@ def generate_core_modules_map(modules: List[dict]) -> str:
 let core_modules : Map[String, RuntimePackage] = {{ {map_content} }}'''
 
 def main():
-    """
-    Main function to generate all core modules.
-    """
+    """Main function to generate all core modules."""
     core_path = Path(CORE_PATH)
 
     if not core_path.exists():
         print(f"Error: Core path {CORE_PATH} does not exist")
         return
+    
     # Get all module directories recursively
     module_dirs = []
     for root, dirs, _ in os.walk(core_path):
         root_path = Path(root)
-        # Skip hidden directories and build artifacts.
         dirs[:] = [
             d
             for d in dirs
@@ -155,21 +200,20 @@ def main():
     generated_modules = []
     module_codes = []
 
-    # Process each module
     for module_dir in sorted(module_dirs):
         print(f"Processing module: {module_dir.name}")
 
         module_info = read_module_info(module_dir)
 
-        if module_info['code'].strip():
+        if module_info and module_info['code'].strip():
             module_code = generate_module_code(module_info)
             if module_code:
                 module_codes.append(module_code)
                 generated_modules.append(module_info)
                 code_lines = len([line for line in module_info['code'].split('\n') if line.strip()])
                 print(f"  Generated module with {code_lines} lines of code")
         else:
-            print(f"  No code content found")
+            print(f"  No code content found (filtered by target)")
 
     # Generate the complete file content
     header = '''///|
@@ -185,17 +229,14 @@ def main():
   }
 }'''
 
-    # Generate core_modules map
     core_modules_map = generate_core_modules_map(generated_modules)
 
-    # Combine all parts
     full_content = "\n\n".join([
         header,
         core_modules_map,
         dummy_loc
     ] + module_codes)
 
-    # Write to output file
     output_path = Path(OUTPUT_FILE)
     with open(output_path, 'w', encoding='utf-8') as f:
         f.write(full_content)