redscript-mc 2.4.0 → 2.4.1

package/dist/types/entity-hierarchy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+export interface EntityTypeNode {
+    name: string;
+    mcId: string | null;
+    abstract: boolean;
+    parent: string | null;
+}
+export declare const ENTITY_TYPES: EntityTypeNode[];
+/** Map from lowercase name → EntityTypeNode */
+export declare const ENTITY_TYPE_MAP: Map<string, EntityTypeNode>;
+/** Map from mcId (without namespace) → EntityTypeNode */
+export declare const ENTITY_TYPE_BY_MCID: Map<string, EntityTypeNode>;
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+export declare function isSubtype(typeA: string, typeB: string): boolean;
+/** True if one type is a subtype of the other (in either direction) */
+export declare function areCompatibleTypes(outerType: string, innerType: string): boolean;
+/** Get all non-abstract leaf types under a given node */
+export declare function getConcreteSubtypes(typeName: string): EntityTypeNode[];
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+export declare function getSelectorEntityType(selector: string): string | null;
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+export declare function getBaseSelectorType(selector: string): string | null;

package/dist/types/entity-hierarchy.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTITY_TYPE_BY_MCID = exports.ENTITY_TYPE_MAP = exports.ENTITY_TYPES = void 0;
+exports.isSubtype = isSubtype;
+exports.areCompatibleTypes = areCompatibleTypes;
+exports.getConcreteSubtypes = getConcreteSubtypes;
+exports.getSelectorEntityType = getSelectorEntityType;
+exports.getBaseSelectorType = getBaseSelectorType;
+exports.ENTITY_TYPES = [
+    // Root
+    { name: 'Entity', mcId: null, abstract: true, parent: null },
+    // Direct children of Entity
+    { name: 'Player', mcId: 'minecraft:player', abstract: false, parent: 'Entity' },
+    { name: 'ArmorStand', mcId: 'minecraft:armor_stand', abstract: false, parent: 'Entity' },
+    { name: 'Item', mcId: 'minecraft:item', abstract: false, parent: 'Entity' },
+    { name: 'Arrow', mcId: 'minecraft:arrow', abstract: false, parent: 'Entity' },
+    // Mob hierarchy
+    { name: 'Mob', mcId: null, abstract: true, parent: 'Entity' },
+    // Hostile mobs
+    { name: 'HostileMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Zombie', mcId: 'minecraft:zombie', abstract: false, parent: 'HostileMob' },
+    { name: 'Skeleton', mcId: 'minecraft:skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'Creeper', mcId: 'minecraft:creeper', abstract: false, parent: 'HostileMob' },
+    { name: 'Spider', mcId: 'minecraft:spider', abstract: false, parent: 'HostileMob' },
+    { name: 'Enderman', mcId: 'minecraft:enderman', abstract: false, parent: 'HostileMob' },
+    { name: 'Blaze', mcId: 'minecraft:blaze', abstract: false, parent: 'HostileMob' },
+    { name: 'Witch', mcId: 'minecraft:witch', abstract: false, parent: 'HostileMob' },
+    { name: 'Slime', mcId: 'minecraft:slime', abstract: false, parent: 'HostileMob' },
+    { name: 'ZombieVillager', mcId: 'minecraft:zombie_villager', abstract: false, parent: 'HostileMob' },
+    { name: 'Husk', mcId: 'minecraft:husk', abstract: false, parent: 'HostileMob' },
+    { name: 'Drowned', mcId: 'minecraft:drowned', abstract: false, parent: 'HostileMob' },
+    { name: 'Stray', mcId: 'minecraft:stray', abstract: false, parent: 'HostileMob' },
+    { name: 'WitherSkeleton', mcId: 'minecraft:wither_skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'CaveSpider', mcId: 'minecraft:cave_spider', abstract: false, parent: 'HostileMob' },
+    // Passive mobs
+    { name: 'PassiveMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Pig', mcId: 'minecraft:pig', abstract: false, parent: 'PassiveMob' },
+    { name: 'Cow', mcId: 'minecraft:cow', abstract: false, parent: 'PassiveMob' },
+    { name: 'Sheep', mcId: 'minecraft:sheep', abstract: false, parent: 'PassiveMob' },
+    { name: 'Chicken', mcId: 'minecraft:chicken', abstract: false, parent: 'PassiveMob' },
+    { name: 'Villager', mcId: 'minecraft:villager', abstract: false, parent: 'PassiveMob' },
+    { name: 'WanderingTrader', mcId: 'minecraft:wandering_trader', abstract: false, parent: 'PassiveMob' },
+];
+/** Map from lowercase name → EntityTypeNode */
+exports.ENTITY_TYPE_MAP = new Map(exports.ENTITY_TYPES.map(t => [t.name.toLowerCase(), t]));
+/** Map from mcId (without namespace) → EntityTypeNode */
+exports.ENTITY_TYPE_BY_MCID = new Map(exports.ENTITY_TYPES
+    .filter(t => t.mcId !== null)
+    .map(t => [t.mcId.replace('minecraft:', ''), t]));
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+function isSubtype(typeA, typeB) {
+    if (typeA === typeB)
+        return true;
+    const node = exports.ENTITY_TYPE_MAP.get(typeA.toLowerCase());
+    if (!node || !node.parent)
+        return false;
+    return isSubtype(node.parent, typeB);
+}
+/** True if one type is a subtype of the other (in either direction) */
+function areCompatibleTypes(outerType, innerType) {
+    return isSubtype(outerType, innerType) || isSubtype(innerType, outerType);
+}
+/** Get all non-abstract leaf types under a given node */
+function getConcreteSubtypes(typeName) {
+    const results = [];
+    for (const node of exports.ENTITY_TYPES) {
+        if (!node.abstract && isSubtype(node.name, typeName)) {
+            results.push(node);
+        }
+    }
+    return results;
+}
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+function getSelectorEntityType(selector) {
+    const match = selector.match(/type=(?:minecraft:)?([a-z_]+)/);
+    if (!match)
+        return null;
+    const mcId = match[1];
+    const node = exports.ENTITY_TYPE_BY_MCID.get(mcId);
+    return node ? node.name : null;
+}
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+function getBaseSelectorType(selector) {
+    const trimmed = selector.trim();
+    // Check for type filter first (works for any selector)
+    const typeFromFilter = getSelectorEntityType(trimmed);
+    if (trimmed.startsWith('@a') || trimmed.startsWith('@p') || trimmed.startsWith('@r')) {
+        return typeFromFilter ?? 'Player';
+    }
+    if (trimmed.startsWith('@e')) {
+        return typeFromFilter ?? 'Entity';
+    }
+    // @s — context-dependent, we don't know unless there's a type filter
+    if (trimmed.startsWith('@s')) {
+        return typeFromFilter ?? null;
+    }
+    return null;
+}
+//# sourceMappingURL=entity-hierarchy.js.map

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.2.34",
+  "version": "1.2.36",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.2.34",
+      "version": "1.2.36",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.2.34",
+  "version": "1.2.36",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/src/index.js",
   "bin": {

package/src/__tests__/array-param.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Tests for array reference parameter passing.
+ *
+ * When a function takes an `int[]` parameter and is called with an array
+ * variable, the compiler monomorphizes the callee per-call-site so that
+ * array index reads/writes inside the callee refer to the caller's actual
+ * NBT storage path.
+ */
+
+import { compile } from '../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  return files.find(f => f.path.includes(pathSubstr))?.content
+}
+
+function getFunctionBody(files: { path: string; content: string }[], fnName: string): string {
+  const content = getFile(files, `${fnName}.mcfunction`)
+  if (!content) {
+    const paths = files.map(f => f.path).join('\n')
+    throw new Error(`Function '${fnName}' not found in output. Files:\n${paths}`)
+  }
+  return content
+}
+
+describe('Array reference parameter passing', () => {
+  const src = `
+    fn swap_elems(arr: int[], i: int, j: int) {
+        let tmp: int = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+    }
+    @keep fn test() {
+        let nums: int[] = [30, 10, 20];
+        swap_elems(nums, 0, 1);
+        scoreboard_set("#out", "test", nums[0]);
+    }
+  `
+
+  let files: { path: string; content: string }[]
+  beforeAll(() => {
+    const result = compile(src, { namespace: 'test' })
+    files = result.files
+  })
+
+  test('compiles without error', () => {
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('a specialized swap function is generated for nums', () => {
+    const specialized = files.filter(f => f.path.includes('swap_elems__arr_'))
+    expect(specialized.length).toBeGreaterThan(0)
+  })
+
+  test('specialized swap function contains "with storage" for dynamic index access', () => {
+    const specialized = files.filter(f => f.path.includes('swap_elems__arr_'))
+    expect(specialized.length).toBeGreaterThan(0)
+    const allContent = specialized.map(f => f.content).join('\n')
+    expect(allContent).toContain('with storage')
+  })
+
+  test('specialized swap function references the correct array path (nums)', () => {
+    const specialized = files.filter(f => f.path.includes('swap_elems__arr_'))
+    const allContent = specialized.map(f => f.content).join('\n')
+    expect(allContent).toContain('nums')
+  })
+
+  test('test function calls the specialized swap variant', () => {
+    const testBody = getFunctionBody(files, 'test')
+    expect(testBody).toContain('swap_elems__arr_')
+  })
+
+  test('original unspecialized swap is not called from test', () => {
+    const testBody = getFunctionBody(files, 'test')
+    // Should not call plain 'swap_elems' (only the specialized variant)
+    expect(testBody).not.toMatch(/function test:swap_elems\b(?!__arr_)/)
+  })
+})

package/src/__tests__/stdlib/math.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Tests for stdlib/math.mcrs functions.
+ * Verifies compilation succeeds and key functions are present.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const MATH_STDLIB = path.join(__dirname, '../../stdlib/math.mcrs')
+const mathSrc = fs.readFileSync(MATH_STDLIB, 'utf-8')
+
+function getFn(files: { path: string; content: string }[], fnName: string): string {
+  const f = files.find(f => f.path.endsWith(`/${fnName}.mcfunction`))
+  if (!f) {
+    const paths = files.map(f => f.path).join('\n')
+    throw new Error(`Function '${fnName}' not found. Files:\n${paths}`)
+  }
+  return f.content
+}
+
+function compileWith(extra: string): { path: string; content: string }[] {
+  const result = compile(mathSrc + '\n' + extra, { namespace: 'test' })
+  return result.files
+}
+
+describe('stdlib/math.mcrs', () => {
+  test('compiles without errors', () => {
+    expect(() => {
+      const result = compile(mathSrc, { namespace: 'test' })
+      expect(result.files.length).toBeGreaterThan(0)
+    }).not.toThrow()
+  })
+
+  test('abs function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let x: int = -5; scoreboard_set("#r","t",abs(x)); }`)
+    // abs function should be called
+    const body = getFn(files, 't')
+    expect(body).toContain('abs')
+  })
+
+  test('factorial(5) compiles and references no recursive calls for n=5', () => {
+    const files = compileWith(`@keep fn t() { let x: int = 5; scoreboard_set("#r","t",factorial(x)); }`)
+    expect(files.some(f => f.path.includes('factorial'))).toBe(true)
+  })
+
+  test('combinations function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let n: int = 5; let k: int = 2; scoreboard_set("#r","t",combinations(n,k)); }`)
+    expect(files.some(f => f.path.includes('combinations'))).toBe(true)
+  })
+
+  test('pow_int function is emitted', () => {
+    const files = compileWith(`@keep fn t() { scoreboard_set("#r","t",pow_int(2,10)); }`)
+    expect(files.some(f => f.path.includes('pow_int'))).toBe(true)
+  })
+
+  test('gcd function is emitted', () => {
+    const files = compileWith(`@keep fn t() { scoreboard_set("#r","t",gcd(12,8)); }`)
+    expect(files.some(f => f.path.includes('gcd'))).toBe(true)
+  })
+
+  test('log2_int function is emitted', () => {
+    const files = compileWith(`@keep fn t() { scoreboard_set("#r","t",log2_int(8)); }`)
+    expect(files.some(f => f.path.includes('log2_int'))).toBe(true)
+  })
+
+  test('sqrt_fx function is emitted (uses isqrt)', () => {
+    const files = compileWith(`@keep fn t() { let x: int = 40000; scoreboard_set("#r","t",sqrt_fx(x)); }`)
+    expect(files.some(f => f.path.includes('sqrt_fx') || f.path.includes('isqrt'))).toBe(true)
+  })
+
+  test('quadratic_disc function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let a: int=1; let b: int=-5; let c: int=6; scoreboard_set("#r","t",quadratic_disc(a,b,c)); }`)
+    expect(files.some(f => f.path.includes('quadratic_disc'))).toBe(true)
+  })
+
+  test('ln function is emitted with atanh implementation', () => {
+    const files = compileWith(`@keep fn t() { let x: int = 20000; scoreboard_set("#r","t",ln(x)); }`)
+    expect(files.some(f => f.path.includes('ln'))).toBe(true)
+    // Should use while loops for range reduction
+    const lnFn = files.find(f => f.path.endsWith('/ln.mcfunction'))
+    if (lnFn) {
+      expect(lnFn.content.length).toBeGreaterThan(0)
+    }
+  })
+
+  test('exp_fx function is emitted', () => {
+    const files = compileWith(`@keep fn t() { let x: int = 10000; scoreboard_set("#r","t",exp_fx(x)); }`)
+    expect(files.some(f => f.path.includes('exp_fx'))).toBe(true)
+  })
+
+  test('min(3,7) = 3 via constant folding', () => {
+    const files = compileWith(`@keep fn t() { scoreboard_set("#r","t",min(3,7)); }`)
+    const body = getFn(files, 't')
+    expect(body).toContain('3')
+  })
+
+  test('clamp is emitted for variable input', () => {
+    const files = compileWith(`@keep fn t() { let x: int = 15; scoreboard_set("#r","t",clamp(x,0,10)); }`)
+    expect(files.some(f => f.path.includes('clamp'))).toBe(true)
+  })
+})

package/src/mir/lower.ts

@@ -63,9 +63,17 @@ export function lowerToMIR(hir: HIRModule, sourceFile?: string): MIRModule {
 
   const timerCounter = { count: 0, timerId: 0 }
 
+  // Build HIR function map for array-arg monomorphization
+  const hirFnMap = new Map<string, HIRFunction>()
+  for (const f of hir.functions) {
+    hirFnMap.set(f.name, f)
+  }
+  // Shared registry: specializedName → [mirFn, ...helpers]
+  const specializedFnsRegistry = new Map<string, MIRFunction[]>()
+
   const allFunctions: MIRFunction[] = []
   for (const f of hir.functions) {
-    const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter)
+    const { fn, helpers } = lowerFunction(f, hir.namespace, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, sourceFile, timerCounter, undefined, hirFnMap, specializedFnsRegistry)
     allFunctions.push(fn, ...helpers)
   }
 
@@ -77,6 +85,11 @@ export function lowerToMIR(hir: HIRModule, sourceFile?: string): MIRModule {
     }
   }
 
+  // Add all specialized (array-monomorphized) functions
+  for (const fns of specializedFnsRegistry.values()) {
+    allFunctions.push(...fns)
+  }
+
   return {
     functions: allFunctions,
     namespace: hir.namespace,
@@ -125,6 +138,10 @@ class FnContext {
   readonly timerCounter: { count: number; timerId: number }
   /** Tracks temps whose values are known compile-time constants (for Timer static ID propagation) */
   readonly constTemps = new Map<Temp, number>()
+  /** HIR function definitions for array-arg monomorphization */
+  hirFunctions: Map<string, HIRFunction> = new Map()
+  /** Shared registry of already-generated specialized (monomorphized) MIR functions */
+  specializedFnsRegistry: Map<string, MIRFunction[]> = new Map()
 
   constructor(
     namespace: string,
@@ -225,21 +242,40 @@ function lowerFunction(
   enumDefs: Map<string, Map<string, number>> = new Map(),
   sourceFile?: string,
   timerCounter: { count: number; timerId: number } = { count: 0, timerId: 0 },
+  /** Pre-bound array variable info for array-parameter monomorphization */
+  arrayArgBindings?: Map<string, { ns: string; pathPrefix: string }>,
+  /** HIR function map for generating specialized callees */
+  hirFnMap?: Map<string, HIRFunction>,
+  /** Shared registry of already-generated specialized MIR functions */
+  specializedFnsRegistry?: Map<string, MIRFunction[]>,
+  /** Override the MIR function name (used when generating specialized versions) */
+  overrideName?: string,
 ): { fn: MIRFunction; helpers: MIRFunction[] } {
-  const ctx = new FnContext(namespace, fn.name, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter)
+  const mirFnName = overrideName ?? fn.name
+  const ctx = new FnContext(namespace, mirFnName, structDefs, implMethods, macroInfo, fnParamInfo, enumDefs, timerCounter)
   ctx.sourceFile = sourceFile
+  if (hirFnMap) ctx.hirFunctions = hirFnMap
+  if (specializedFnsRegistry) ctx.specializedFnsRegistry = specializedFnsRegistry
   const fnMacroInfo = macroInfo.get(fn.name)
 
-  // Create temps for parameters
-  const params: { name: Temp; isMacroParam: boolean }[] = fn.params.map(p => {
-    const t = ctx.freshTemp()
-    return { name: t, isMacroParam: fnMacroInfo?.macroParams.has(p.name) ?? false }
-  })
+  // Pre-populate arrayVars from caller-provided array bindings
+  if (arrayArgBindings) {
+    for (const [paramName, arrInfo] of arrayArgBindings) {
+      ctx.arrayVars.set(paramName, arrInfo)
+    }
+  }
 
-  // Map parameter names to their temps
+  // Create temps for parameters, skipping array-type params that are pre-bound
+  const params: { name: Temp; isMacroParam: boolean }[] = []
   const scope = new Map<string, Temp>()
-  fn.params.forEach((p, i) => {
-    scope.set(p.name, params[i].name)
+  fn.params.forEach((p) => {
+    if (p.type.kind === 'array' && arrayArgBindings?.has(p.name)) {
+      // Array param already bound via arrayVars; no scoreboard slot needed
+      return
+    }
+    const t = ctx.freshTemp()
+    params.push({ name: t, isMacroParam: fnMacroInfo?.macroParams.has(p.name) ?? false })
+    scope.set(p.name, t)
   })
 
   lowerBlock(fn.body, ctx, scope)
@@ -258,7 +294,7 @@ function lowerFunction(
   computePreds(liveBlocks)
 
   const result: MIRFunction = {
-    name: fn.name,
+    name: mirFnName,
     params,
     blocks: liveBlocks,
     entry: 'entry',
@@ -1319,6 +1355,68 @@ function lowerExpr(
         return { kind: 'temp', name: t }
       }
 
+      // --- Array-parameter monomorphization ---
+      // Detect if any argument is an array variable; if so, generate a
+      // specialized callee version with array info pre-bound (per call-site).
+      {
+        const targetHirFn = ctx.hirFunctions.get(expr.fn)
+        if (targetHirFn && ctx.specializedFnsRegistry) {
+          const arrayArgBindings = new Map<string, { ns: string; pathPrefix: string }>()
+          for (let i = 0; i < expr.args.length; i++) {
+            const arg = expr.args[i]
+            if (arg.kind === 'ident' && ctx.arrayVars.has(arg.name)) {
+              const paramName = targetHirFn.params[i]?.name
+              if (paramName) {
+                arrayArgBindings.set(paramName, ctx.arrayVars.get(arg.name)!)
+              }
+            }
+          }
+          if (arrayArgBindings.size > 0) {
+            // Build a deterministic specialized function name from the array bindings
+            const bindingKey = [...arrayArgBindings.entries()]
+              .sort(([a], [b]) => a.localeCompare(b))
+              .map(([p, { ns, pathPrefix }]) => `${p}__${ns.replace(/[^a-zA-Z0-9]/g, '_')}__${pathPrefix.replace(/[^a-zA-Z0-9]/g, '_')}`)
+              .join('__')
+            const specializedName = `${expr.fn}__arr_${bindingKey}`
+
+            // Generate the specialized function if not already done
+            if (!ctx.specializedFnsRegistry.has(specializedName)) {
+              // Placeholder to prevent re-entry
+              ctx.specializedFnsRegistry.set(specializedName, [])
+              const { fn: specFn, helpers: specHelpers } = lowerFunction(
+                targetHirFn,
+                ctx.getNamespace(),
+                ctx.structDefs,
+                ctx.implMethods,
+                ctx.macroInfo,
+                ctx.fnParamInfo,
+                ctx.enumDefs,
+                ctx.sourceFile,
+                ctx.timerCounter,
+                arrayArgBindings,
+                ctx.hirFunctions,
+                ctx.specializedFnsRegistry,
+                specializedName,
+              )
+              ctx.specializedFnsRegistry.set(specializedName, [specFn, ...specHelpers])
+            }
+
+            // Emit call to the specialized function, passing only non-array args
+            const nonArrayArgs: Operand[] = []
+            for (let i = 0; i < expr.args.length; i++) {
+              const param = targetHirFn.params[i]
+              if (!param || param.type.kind !== 'array' || !arrayArgBindings.has(param.name)) {
+                nonArrayArgs.push(lowerExpr(expr.args[i], ctx, scope))
+              }
+            }
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'call', dst: t, fn: specializedName, args: nonArrayArgs })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+      // --- end array monomorphization ---
+
       const args = expr.args.map(a => lowerExpr(a, ctx, scope))
       const t = ctx.freshTemp()
       ctx.emit({ kind: 'call', dst: t, fn: expr.fn, args })

package/src/stdlib/list.mcrs

@@ -94,3 +94,79 @@ fn weighted3(seed: int, w0: int, w1: int, w2: int): int {
     if (v < w0 + w1) { return 1; }
     return 2;
 }
+
+// ─── Sorting networks (fixed-size, optimal compare-swap count) ────────────────
+
+// sort4(a,b,c,d, pos): sort 4 values, return value at position pos (0=min)
+// Uses 5-comparison optimal sorting network
+fn sort4(a: int, b: int, c: int, d: int, pos: int): int {
+    let w: int = a; let x: int = b; let y: int = c; let z: int = d;
+    // Sorting network for 4 elements
+    if (w > x) { let t: int = w; w = x; x = t; }
+    if (y > z) { let t: int = y; y = z; z = t; }
+    if (w > y) { let t: int = w; w = y; y = t; }
+    if (x > z) { let t: int = x; x = z; z = t; }
+    if (x > y) { let t: int = x; x = y; y = t; }
+    if (pos == 0) { return w; }
+    if (pos == 1) { return x; }
+    if (pos == 2) { return y; }
+    return z;
+}
+
+// sort5(a,b,c,d,e, pos): sort 5 values, return value at position pos
+// Uses 9-comparison sorting network
+fn sort5(a: int, b: int, c: int, d: int, e: int, pos: int): int {
+    let v0: int = a; let v1: int = b; let v2: int = c; let v3: int = d; let v4: int = e;
+    // 9-comparison sorting network (Batcher odd-even merge sort)
+    if (v0 > v1) { let t: int = v0; v0 = v1; v1 = t; }
+    if (v2 > v3) { let t: int = v2; v2 = v3; v3 = t; }
+    if (v0 > v2) { let t: int = v0; v0 = v2; v2 = t; }
+    if (v1 > v4) { let t: int = v1; v1 = v4; v4 = t; }
+    if (v0 > v1) { let t: int = v0; v0 = v1; v1 = t; }
+    if (v2 > v3) { let t: int = v2; v2 = v3; v3 = t; }
+    if (v1 > v2) { let t: int = v1; v1 = v2; v2 = t; }
+    if (v3 > v4) { let t: int = v3; v3 = v4; v4 = t; }
+    if (v2 > v3) { let t: int = v2; v2 = v3; v3 = t; }
+    if (pos == 0) { return v0; }
+    if (pos == 1) { return v1; }
+    if (pos == 2) { return v2; }
+    if (pos == 3) { return v3; }
+    return v4;
+}
+
+// ─── Dynamic sort (arbitrary-length, uses array reference passing) ─────────────
+
+// list_sort_asc(arr, len): in-place ascending bubble sort
+// Requires RedScript ≥ 2.4.0 (array parameter by reference)
+fn list_sort_asc(arr: int[], len: int) {
+    let i: int = 0;
+    while (i < len - 1) {
+        let j: int = 0;
+        while (j < len - 1 - i) {
+            if (arr[j] > arr[j + 1]) {
+                let tmp: int = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = tmp;
+            }
+            j = j + 1;
+        }
+        i = i + 1;
+    }
+}
+
+// list_sort_desc(arr, len): in-place descending bubble sort
+fn list_sort_desc(arr: int[], len: int) {
+    let i: int = 0;
+    while (i < len - 1) {
+        let j: int = 0;
+        while (j < len - 1 - i) {
+            if (arr[j] < arr[j + 1]) {
+                let tmp: int = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = tmp;
+            }
+            j = j + 1;
+        }
+        i = i + 1;
+    }
+}