rip-lang 3.7.4 → 3.8.9

package/src/compiler.js

@@ -148,6 +148,7 @@ export class CodeGenerator {
 
     // Special operators
     '%%': 'generateModulo',
+    '%%=': 'generateModuloAssign',
     '//': 'generateFloorDiv',
     '//=': 'generateFloorDivAssign',
     '..': 'generateRange',
@@ -201,9 +202,7 @@ export class CodeGenerator {
 
     // Control flow — simple
     'break': 'generateBreak',
-    'break-if': 'generateBreakIf',
     'continue': 'generateContinue',
-    'continue-if': 'generateContinueIf',
     '?': 'generateExistential',
     '?:': 'generateTernary',
     '|>': 'generatePipe',
@@ -215,12 +214,10 @@ export class CodeGenerator {
 
     // Control flow — complex
     'if': 'generateIf',
-    'unless': 'generateIf',
     'for-in': 'generateForIn',
     'for-of': 'generateForOf',
     'for-as': 'generateForAs',
     'while': 'generateWhile',
-    'until': 'generateUntil',
     'try': 'generateTry',
     'throw': 'generateThrow',
     'control': 'generateControl',
@@ -311,17 +308,16 @@ export class CodeGenerator {
     collect(sexpr);
 
     // Match output lines to collected statement locations in parallel.
-    // Skip generated lines that have no source correspondence.
+    // Skip lines with no source correspondence (preamble, braces, etc.).
     let lines = code.split('\n');
     let locIdx = 0;
     for (let outLine = 0; outLine < lines.length; outLine++) {
       let line = lines[outLine];
       let trimmed = line.trim();
 
-      // Skip lines with no source correspondence
       if (!trimmed || trimmed === '}' || trimmed === '});') continue;
       if (trimmed.startsWith('let ') || trimmed.startsWith('var ')) continue;
-      if (trimmed.startsWith('const slice') || trimmed.startsWith('const modulo') || trimmed.startsWith('const toSearchable')) continue;
+      if (trimmed.startsWith('const slice') || trimmed.startsWith('const modulo') || trimmed.startsWith('const toMatchable')) continue;
       if (trimmed.startsWith('const {') && trimmed.includes('__')) continue;
       if (trimmed.startsWith('} else')) continue;
       if (trimmed.startsWith('//# source')) continue;
@@ -359,6 +355,7 @@ export class CodeGenerator {
     }
 
     if (head === 'readonly') return;
+    if (head === 'component') return;  // Component body has its own scope
 
     if (CodeGenerator.ASSIGNMENT_OPS.has(head)) {
       let [target, value] = rest;
@@ -384,13 +381,6 @@ export class CodeGenerator {
       return;
     }
 
-    if (head === 'unless') {
-      let [condition, body] = rest;
-      this.collectProgramVariables(condition);
-      this.collectProgramVariables(body);
-      return;
-    }
-
     if (head === 'try') {
       this.collectProgramVariables(rest[0]);
       if (rest.length >= 2 && Array.isArray(rest[1]) && rest[1].length === 2 && rest[1][0] !== 'block') {
@@ -545,7 +535,7 @@ export class CodeGenerator {
         return `super.${this.currentMethodName}(${args})`;
       }
 
-      // Postfix if/unless on single-arg call
+      // Postfix if on single-arg call
       if (context === 'statement' && rest.length === 1) {
         let cond = this.findPostfixConditional(rest[0]);
         if (cond) {
@@ -554,7 +544,7 @@ export class CodeGenerator {
           let condCode = this.generate(cond.condition, 'value');
           let valCode = this.generate(argWithout, 'value');
           let callStr = `${callee}(${valCode})`;
-          return cond.type === 'unless' ? `if (!${condCode}) ${callStr}` : `if (${condCode}) ${callStr}`;
+          return `if (${condCode}) ${callStr}`;
         }
       }
 
@@ -567,7 +557,7 @@ export class CodeGenerator {
 
     // Statement sequence (comma operator)
     if (Array.isArray(head) && typeof head[0] === 'string') {
-      let stmtOps = ['=', '+=', '-=', '*=', '/=', '%=', '**=', '&&=', '||=', '??=', 'if', 'unless', 'return', 'throw'];
+      let stmtOps = ['=', '+=', '-=', '*=', '/=', '%=', '**=', '&&=', '||=', '??=', 'if', 'return', 'throw'];
       if (stmtOps.includes(head[0])) {
         let exprs = sexpr.map(stmt => this.generate(stmt, 'value'));
         return `(${exprs.join(', ')})`;
@@ -585,7 +575,7 @@ export class CodeGenerator {
         return `new ${needsParens ? `(${ctorCode})` : ctorCode}(${args})`;
       }
 
-      // Postfix if/unless on single-arg method call
+      // Postfix if on single-arg method call
       if (context === 'statement' && rest.length === 1) {
         let cond = this.findPostfixConditional(rest[0]);
         if (cond) {
@@ -594,7 +584,7 @@ export class CodeGenerator {
           let condCode = this.generate(cond.condition, 'value');
           let valCode = this.generate(argWithout, 'value');
           let callStr = `${calleeCode}(${valCode})`;
-          return cond.type === 'unless' ? `if (!${condCode}) ${callStr}` : `if (${condCode}) ${callStr}`;
+          return `if (${condCode}) ${callStr}`;
         }
       }
 
@@ -638,7 +628,7 @@ export class CodeGenerator {
     }
 
     // Generate body first to detect needed helpers
-    let blockStmts = ['def', 'class', 'if', 'unless', 'for-in', 'for-of', 'for-as', 'while', 'until', 'loop', 'switch', 'try'];
+    let blockStmts = ['def', 'class', 'if', 'for-in', 'for-of', 'for-as', 'while', 'loop', 'switch', 'try'];
     let statementsCode = other.map((stmt, index) => {
       let isSingle = other.length === 1 && imports.length === 0 && exports.length === 0;
       let isObj = this.is(stmt, 'object');
@@ -680,8 +670,8 @@ export class CodeGenerator {
     if (!skip) {
       if (this.helpers.has('slice'))      { code += 'const slice = [].slice;\n'; needsBlank = true; }
       if (this.helpers.has('modulo'))     { code += 'const modulo = (n, d) => { n = +n; d = +d; return (n % d + d) % d; };\n'; needsBlank = true; }
-      if (this.helpers.has('toSearchable')) {
-        code += 'const toSearchable = (v, allowNewlines) => {\n';
+      if (this.helpers.has('toMatchable')) {
+        code += 'const toMatchable = (v, allowNewlines) => {\n';
         code += '  if (typeof v === "string") return !allowNewlines && /[\\n\\r]/.test(v) ? null : v;\n';
         code += '  if (v == null) return "";\n';
         code += '  if (typeof v === "number" || typeof v === "bigint" || typeof v === "boolean") return String(v);\n';
@@ -781,6 +771,13 @@ export class CodeGenerator {
     return `modulo(${this.generate(left, 'value')}, ${this.generate(right, 'value')})`;
   }
 
+  generateModuloAssign(head, rest) {
+    let [target, value] = rest;
+    this.helpers.add('modulo');
+    let t = this.generate(target, 'value'), v = this.generate(value, 'value');
+    return `${t} = modulo(${t}, ${v})`;
+  }
+
   generateFloorDiv(head, rest) {
     let [left, right] = rest;
     return `Math.floor(${this.generate(left, 'value')} / ${this.generate(right, 'value')})`;
@@ -870,33 +867,29 @@ export class CodeGenerator {
       }
     }
 
-    // Postfix if/unless on assignment with || operator
+    // Postfix if on assignment with || operator
     if (context === 'statement' && head === '=' && Array.isArray(value) &&
         (value[0] === '||' || value[0] === '&&') && value.length === 3) {
       let [binOp, left, right] = value;
-      if ((this.is(right, 'unless') || this.is(right, 'if')) && right.length === 3) {
-        let [condType, condition, wrappedValue] = right;
+      if (this.is(right, 'if') && right.length === 3) {
+        let [, condition, wrappedValue] = right;
         let unwrapped = Array.isArray(wrappedValue) && wrappedValue.length === 1 ? wrappedValue[0] : wrappedValue;
         let fullValue = [binOp, left, unwrapped];
         let t = this.generate(target, 'value'), c = this.generate(condition, 'value'), v = this.generate(fullValue, 'value');
-        return condType === 'unless' ? `if (!${c}) ${t} = ${v}` : `if (${c}) ${t} = ${v}`;
+        return `if (${c}) ${t} = ${v}`;
       }
     }
 
-    // Postfix if/unless on simple assignment
+    // Postfix if on simple assignment
     if (context === 'statement' && head === '=' && Array.isArray(value) && value.length === 3) {
       let [valHead, condition, actualValue] = value;
       let isPostfix = Array.isArray(actualValue) && actualValue.length === 1 &&
                       (!Array.isArray(actualValue[0]) || actualValue[0][0] !== 'block');
-      if ((valHead === 'unless' || valHead === 'if') && isPostfix) {
+      if (valHead === 'if' && isPostfix) {
         let unwrapped = Array.isArray(actualValue) && actualValue.length === 1 ? actualValue[0] : actualValue;
         let t = this.generate(target, 'value');
         let condCode = this.unwrapLogical(this.generate(condition, 'value'));
         let v = this.generate(unwrapped, 'value');
-        if (valHead === 'unless') {
-          if (condCode.includes(' ') || /[<>=&|]/.test(condCode)) condCode = `(${condCode})`;
-          return `if (!${condCode}) ${t} = ${v}`;
-        }
         return `if (${condCode}) ${t} = ${v}`;
       }
     }
@@ -929,11 +922,17 @@ export class CodeGenerator {
 
   generatePropertyAccess(head, rest, context, sexpr) {
     let [obj, prop] = rest;
+    // In subclass constructors, rewrite @param refs (this.x) to _x for super() safety
+    if (this._atParamMap && obj === 'this') {
+      let mapped = this._atParamMap.get(str(prop));
+      if (mapped) return mapped;
+    }
     this.suppressReactiveUnwrap = true;
     let objCode = this.generate(obj, 'value');
     this.suppressReactiveUnwrap = false;
     let needsParens = CodeGenerator.NUMBER_LITERAL_RE.test(objCode) ||
-                      ((this.is(obj, 'object') || this.is(obj, 'await') || this.is(obj, 'yield')));
+                      objCode.startsWith('await ') ||
+                      ((this.is(obj, 'object') || this.is(obj, 'yield')));
     let base = needsParens ? `(${objCode})` : objCode;
     if (meta(prop, 'await') === true) return `await ${base}.${str(prop)}()`;
     if (meta(prop, 'predicate')) return `(${base}.${str(prop)} != null)`;
@@ -947,12 +946,12 @@ export class CodeGenerator {
 
   generateRegexIndex(head, rest) {
     let [value, regex, captureIndex] = rest;
-    this.helpers.add('toSearchable');
+    this.helpers.add('toMatchable');
     this.programVars.add('_');
     let v = this.generate(value, 'value'), r = this.generate(regex, 'value');
     let idx = captureIndex !== null ? this.generate(captureIndex, 'value') : '0';
     let allowNL = r.includes('/m') ? ', true' : '';
-    return `(_ = toSearchable(${v}${allowNL}).match(${r})) && _[${idx}]`;
+    return `(_ = toMatchable(${v}${allowNL}).match(${r})) && _[${idx}]`;
   }
 
   generateIndexAccess(head, rest) {
@@ -1062,11 +1061,6 @@ export class CodeGenerator {
     let [expr] = rest;
     if (this.sideEffectOnly) return 'return';
 
-    if (this.is(expr, 'unless')) {
-      let [, condition, body] = expr;
-      let val = Array.isArray(body) && body.length === 1 ? body[0] : body;
-      return `if (!${this.generate(condition, 'value')}) return ${this.generate(val, 'value')}`;
-    }
     if (this.is(expr, 'if')) {
       let [, condition, body, ...elseParts] = expr;
       if (elseParts.length === 0) {
@@ -1074,11 +1068,10 @@ export class CodeGenerator {
         return `if (${this.generate(condition, 'value')}) return ${this.generate(val, 'value')}`;
       }
     }
-    if (this.is(expr, 'new') && Array.isArray(expr[1]) && expr[1][0] === 'unless') {
-      let [, unlessNode] = expr;
-      let [, condition, body] = unlessNode;
+    if (this.is(expr, 'new') && Array.isArray(expr[1]) && expr[1][0] === 'if') {
+      let [, condition, body] = expr[1];
       let val = Array.isArray(body) && body.length === 1 ? body[0] : body;
-      return `if (!${this.generate(condition, 'value')}) return ${this.generate(['new', val], 'value')}`;
+      return `if (${this.generate(condition, 'value')}) return ${this.generate(['new', val], 'value')}`;
     }
     return `return ${this.generate(expr, 'value')}`;
   }
@@ -1134,9 +1127,7 @@ export class CodeGenerator {
   // ---------------------------------------------------------------------------
 
   generateBreak()    { return 'break'; }
-  generateBreakIf(head, rest)    { return `if (${this.generate(rest[0], 'value')}) break`; }
   generateContinue() { return 'continue'; }
-  generateContinueIf(head, rest) { return `if (${this.generate(rest[0], 'value')}) continue`; }
 
   generateExistential(head, rest) {
     return `(${this.generate(rest[0], 'value')} != null)`;
@@ -1198,16 +1189,6 @@ export class CodeGenerator {
   // ---------------------------------------------------------------------------
 
   generateIf(head, rest, context, sexpr) {
-    if (head === 'unless') {
-      let [condition, body] = rest;
-      if (Array.isArray(body) && body.length === 1 && (!Array.isArray(body[0]) || body[0][0] !== 'block')) body = body[0];
-      if (context === 'value') {
-        return `(!${this.generate(condition, 'value')} ? ${this.extractExpression(body)} : undefined)`;
-      }
-      let condCode = this.unwrap(this.generate(condition, 'value'));
-      if (/[ <>=&|]/.test(condCode)) condCode = `(${condCode})`;
-      return `if (!${condCode}) ` + this.generate(body, 'statement');
-    }
     let [condition, thenBranch, ...elseBranches] = rest;
     return context === 'value'
       ? this.generateIfAsExpression(condition, thenBranch, elseBranches)
@@ -1431,11 +1412,6 @@ export class CodeGenerator {
     return code + (guard ? this.generateLoopBodyWithGuard(body, guard) : this.generateLoopBody(body));
   }
 
-  generateUntil(head, rest) {
-    let [cond, body] = rest;
-    return `while (!(${this.unwrap(this.generate(cond, 'value'))})) ` + this.generateLoopBody(body);
-  }
-
   generateRange(head, rest) {
     if (head === '...') {
       if (rest.length === 1) return `...${this.generate(rest[0], 'value')}`;
@@ -1504,11 +1480,11 @@ export class CodeGenerator {
 
   generateRegexMatch(head, rest) {
     let [left, right] = rest;
-    this.helpers.add('toSearchable');
+    this.helpers.add('toMatchable');
     this.programVars.add('_');
     let r = this.generate(right, 'value');
     let allowNL = r.includes('/m') ? ', true' : '';
-    return `(_ = toSearchable(${this.generate(left, 'value')}${allowNL}).match(${r}))`;
+    return `(_ = toMatchable(${this.generate(left, 'value')}${allowNL}).match(${r}))`;
   }
 
   generateNew(head, rest) {
@@ -1574,7 +1550,11 @@ export class CodeGenerator {
       let keyCode;
       if (this.is(key, 'dynamicKey')) keyCode = `[${this.generate(key[1], 'value')}]`;
       else if (this.is(key, 'str')) keyCode = `[${this.generate(key, 'value')}]`;
-      else keyCode = this.generate(key, 'value');
+      else {
+        this.suppressReactiveUnwrap = true;
+        keyCode = this.generate(key, 'value');
+        this.suppressReactiveUnwrap = false;
+      }
       let valCode = this.generate(value, 'value');
       if (operator === '=') return `${keyCode} = ${valCode}`;
       if (operator === ':') return `${keyCode}: ${valCode}`;
@@ -1642,20 +1622,18 @@ export class CodeGenerator {
     let [expr] = rest;
     if (Array.isArray(expr)) {
       let checkExpr = expr, wrapperType = null;
-      if (expr[0] === 'new' && Array.isArray(expr[1]) && (expr[1][0] === 'if' || expr[1][0] === 'unless')) {
+      if (expr[0] === 'new' && Array.isArray(expr[1]) && expr[1][0] === 'if') {
         wrapperType = 'new'; checkExpr = expr[1];
-      } else if (expr[0] === 'if' || expr[0] === 'unless') {
+      } else if (expr[0] === 'if') {
         checkExpr = expr;
       }
-      if (checkExpr[0] === 'if' || checkExpr[0] === 'unless') {
-        let [condType, condition, body] = checkExpr;
+      if (checkExpr[0] === 'if') {
+        let [, condition, body] = checkExpr;
         let unwrapped = Array.isArray(body) && body.length === 1 ? body[0] : body;
         expr = wrapperType === 'new' ? ['new', unwrapped] : unwrapped;
         let condCode = this.generate(condition, 'value');
         let throwCode = `throw ${this.generate(expr, 'value')}`;
-        return condType === 'unless'
-          ? `if (!(${condCode})) {\n${this.indent()}  ${throwCode};\n${this.indent()}}`
-          : `if (${condCode}) {\n${this.indent()}  ${throwCode};\n${this.indent()}}`;
+        return `if (${condCode}) {\n${this.indent()}  ${throwCode};\n${this.indent()}}`;
       }
     }
     let throwStmt = `throw ${this.generate(expr, 'value')}`;
@@ -1729,6 +1707,65 @@ export class CodeGenerator {
   // Comprehensions
   // ---------------------------------------------------------------------------
 
+  // Shared: parse a for-in iterator and return { header, setup }.
+  //   header: the for(...) clause (no trailing brace)
+  //   setup:  any `const x = arr[i]` preamble line, or null
+  _forInHeader(vars, iterable, step) {
+    let va = Array.isArray(vars) ? vars : [vars];
+    let noVar = va.length === 0;
+    let [itemVar, indexVar] = noVar ? ['_i', null] : va;
+    let ivp = (this.is(itemVar, 'array') || this.is(itemVar, 'object'))
+      ? this.generateDestructuringPattern(itemVar) : itemVar;
+
+    if (step && step !== null) {
+      let ih = Array.isArray(iterable) && iterable[0];
+      if (ih instanceof String) ih = str(ih);
+      let isRange = ih === '..' || ih === '...';
+      if (isRange) {
+        let isExcl = ih === '...';
+        let [s, e] = iterable.slice(1);
+        let sc = this.generate(s, 'value'), ec = this.generate(e, 'value'), stc = this.generate(step, 'value');
+        return { header: `for (let ${ivp} = ${sc}; ${ivp} ${isExcl ? '<' : '<='} ${ec}; ${ivp} += ${stc})`, setup: null };
+      }
+      let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
+      let isNeg = this.is(step, '-', 1);
+      let isMinus1 = isNeg && (step[1] === '1' || step[1] === 1 || str(step[1]) === '1');
+      let isPlus1 = !isNeg && (step === '1' || step === 1 || str(step) === '1');
+      let update = isMinus1 ? `${idxN}--` : isPlus1 ? `${idxN}++` : `${idxN} += ${stc}`;
+      let header = isNeg
+        ? `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${update})`
+        : `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${update})`;
+      return { header, setup: noVar ? null : `const ${ivp} = ${ic}[${idxN}];` };
+    }
+    if (indexVar) {
+      let ic = this.generate(iterable, 'value');
+      return {
+        header: `for (let ${indexVar} = 0; ${indexVar} < ${ic}.length; ${indexVar}++)`,
+        setup: `const ${ivp} = ${ic}[${indexVar}];`,
+      };
+    }
+    return { header: `for (const ${ivp} of ${this.generate(iterable, 'value')})`, setup: null };
+  }
+
+  // Shared: parse a for-of (object) iterator and return { header, own, vv, oc, kvp }.
+  _forOfHeader(vars, iterable, own) {
+    let va = Array.isArray(vars) ? vars : [vars];
+    let [kv, vv] = va;
+    let kvp = (this.is(kv, 'array') || this.is(kv, 'object'))
+      ? this.generateDestructuringPattern(kv) : kv;
+    let oc = this.generate(iterable, 'value');
+    return { header: `for (const ${kvp} in ${oc})`, own, vv, oc, kvp };
+  }
+
+  // Shared: parse a for-as (iterator) spec and return { header }.
+  _forAsHeader(vars, iterable, isAwait) {
+    let va = Array.isArray(vars) ? vars : [vars];
+    let [fv] = va;
+    let ivp = (this.is(fv, 'array') || this.is(fv, 'object'))
+      ? this.generateDestructuringPattern(fv) : fv;
+    return { header: `for ${isAwait ? 'await ' : ''}(const ${ivp} of ${this.generate(iterable, 'value')})` };
+  }
+
   generateComprehension(head, rest, context) {
     let [expr, iterators, guards] = rest;
     if (context === 'statement') return this.generateComprehensionAsLoop(expr, iterators, guards);
@@ -1743,59 +1780,19 @@ export class CodeGenerator {
     for (let iter of iterators) {
       let [iterType, vars, iterable, stepOrOwn] = iter;
       if (iterType === 'for-in') {
-        let step = stepOrOwn;
-        let va = Array.isArray(vars) ? vars : [vars];
-        let noVar = va.length === 0;
-        let [itemVar, indexVar] = noVar ? ['_i', null] : va;
-        let ivp = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
-          ? this.generateDestructuringPattern(itemVar) : itemVar;
-
-        if (step && step !== null) {
-          let ih = Array.isArray(iterable) && iterable[0];
-          if (ih instanceof String) ih = str(ih);
-          let isRange = ih === '..' || ih === '...';
-          if (isRange) {
-            let isExcl = ih === '...';
-            let [s, e] = iterable.slice(1);
-            let sc = this.generate(s, 'value'), ec = this.generate(e, 'value'), stc = this.generate(step, 'value');
-            code += this.indent() + `for (let ${ivp} = ${sc}; ${ivp} ${isExcl ? '<' : '<='} ${ec}; ${ivp} += ${stc}) {\n`;
-            this.indentLevel++;
-          } else {
-            let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
-            let isNeg = this.is(step, '-', 1);
-            code += isNeg
-              ? this.indent() + `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${idxN} += ${stc}) {\n`
-              : this.indent() + `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${idxN} += ${stc}) {\n`;
-            this.indentLevel++;
-            if (!noVar) code += this.indent() + `const ${ivp} = ${ic}[${idxN}];\n`;
-          }
-        } else if (indexVar) {
-          let ic = this.generate(iterable, 'value');
-          code += this.indent() + `for (let ${indexVar} = 0; ${indexVar} < ${ic}.length; ${indexVar}++) {\n`;
-          this.indentLevel++;
-          code += this.indent() + `const ${ivp} = ${ic}[${indexVar}];\n`;
-        } else {
-          code += this.indent() + `for (const ${ivp} of ${this.generate(iterable, 'value')}) {\n`;
-          this.indentLevel++;
-        }
+        let { header, setup } = this._forInHeader(vars, iterable, stepOrOwn);
+        code += this.indent() + header + ' {\n';
+        this.indentLevel++;
+        if (setup) code += this.indent() + setup + '\n';
       } else if (iterType === 'for-of') {
-        let own = stepOrOwn;
-        let va = Array.isArray(vars) ? vars : [vars];
-        let [kv, vv] = va;
-        let kvp = ((this.is(kv, 'array') || this.is(kv, 'object')))
-          ? this.generateDestructuringPattern(kv) : kv;
-        let oc = this.generate(iterable, 'value');
-        code += this.indent() + `for (const ${kvp} in ${oc}) {\n`;
+        let { header, own, vv, oc, kvp } = this._forOfHeader(vars, iterable, stepOrOwn);
+        code += this.indent() + header + ' {\n';
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kvp})) continue;\n`;
         if (vv) code += this.indent() + `const ${vv} = ${oc}[${kvp}];\n`;
       } else if (iterType === 'for-as') {
-        let isAwait = iter[3];
-        let va = Array.isArray(vars) ? vars : [vars];
-        let [fv] = va;
-        let ivp = ((this.is(fv, 'array') || this.is(fv, 'object')))
-          ? this.generateDestructuringPattern(fv) : fv;
-        code += this.indent() + `for ${isAwait ? 'await ' : ''}(const ${ivp} of ${this.generate(iterable, 'value')}) {\n`;
+        let { header } = this._forAsHeader(vars, iterable, iter[3]);
+        code += this.indent() + header + ' {\n';
         this.indentLevel++;
       }
     }
@@ -1808,12 +1805,12 @@ export class CodeGenerator {
     let hasCtrl = (node) => {
       if (typeof node === 'string' && (node === 'break' || node === 'continue')) return true;
       if (!Array.isArray(node)) return false;
-      if (['break', 'continue', 'break-if', 'continue-if', 'return', 'throw'].includes(node[0])) return true;
-      if (node[0] === 'if' || node[0] === 'unless') return node.slice(1).some(hasCtrl);
+      if (['break', 'continue', 'return', 'throw'].includes(node[0])) return true;
+      if (node[0] === 'if') return node.slice(1).some(hasCtrl);
       return node.some(hasCtrl);
     };
 
-    let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'until', 'loop'];
+    let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'loop'];
     if (this.is(expr, 'block')) {
       for (let i = 0; i < expr.length - 1; i++) {
         let s = expr[i + 1], isLast = i === expr.length - 2;
@@ -1909,17 +1906,36 @@ export class CodeGenerator {
               let hasAwait = this.containsAwait(body), hasYield = this.containsYield(body);
               let cleanParams = params, autoAssign = [];
               if (mName === 'constructor') {
+                let isSubclass = !!parentClass;
+                let atParamMap = isSubclass ? new Map() : null;
                 cleanParams = params.map(p => {
-                  if (this.is(p, '.') && p[1] === 'this') { autoAssign.push(`this.${p[2]} = ${p[2]}`); return p[2]; }
+                  // Handle @param: ['.', 'this', 'name']
+                  if (this.is(p, '.') && p[1] === 'this') {
+                    let name = p[2];
+                    let param = isSubclass ? `_${name}` : name;
+                    autoAssign.push(`this.${name} = ${param}`);
+                    if (isSubclass) atParamMap.set(name, param);
+                    return param;
+                  }
+                  // Handle @param with default: ['default', ['.', 'this', 'name'], value]
+                  if (this.is(p, 'default') && this.is(p[1], '.') && p[1][1] === 'this') {
+                    let name = p[1][2];
+                    let param = isSubclass ? `_${name}` : name;
+                    autoAssign.push(`this.${name} = ${param}`);
+                    if (isSubclass) atParamMap.set(name, param);
+                    return ['default', param, p[2]];
+                  }
                   return p;
                 });
                 for (let bm of boundMethods) autoAssign.unshift(`this.${bm} = this.${bm}.bind(this)`);
+                if (atParamMap?.size > 0) this._atParamMap = atParamMap;
               }
               let pList = this.generateParamList(cleanParams);
               let prefix = (isStatic ? 'static ' : '') + (hasAwait ? 'async ' : '') + (hasYield ? '*' : '');
               code += this.indent() + `${prefix}${mName}(${pList}) `;
               if (!isComputed) this.currentMethodName = mName;
               code += this.generateMethodBody(body, autoAssign, mName === 'constructor', cleanParams);
+              this._atParamMap = null;
               this.currentMethodName = null;
               code += '\n';
             } else if (isStatic) {
@@ -2098,7 +2114,7 @@ export class CodeGenerator {
   findPostfixConditional(expr) {
     if (!Array.isArray(expr)) return null;
     let h = expr[0];
-    if ((h === 'unless' || h === 'if') && expr.length === 3) return {type: h, condition: expr[1], value: expr[2]};
+    if (h === 'if' && expr.length === 3) return {type: h, condition: expr[1], value: expr[2]};
     if (h === '+' || h === '-' || h === '*' || h === '/') {
       for (let i = 1; i < expr.length; i++) {
         let found = this.findPostfixConditional(expr[i]);
@@ -2192,7 +2208,7 @@ export class CodeGenerator {
       !this.scopeStack.some(s => s.has(v))  // don't re-declare variables from enclosing scopes
     ));
     let noRetStmts = ['return', 'throw', 'break', 'continue'];
-    let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'until', 'loop'];
+    let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'loop'];
 
     // Track this function's scope so nested functions don't re-declare its variables
     this.scopeStack.push(new Set([...newVars, ...paramNames]));
@@ -2240,7 +2256,7 @@ export class CodeGenerator {
             return;
           }
 
-          if (!isConstructor && !sideEffectOnly && isLast && (h === 'if' || h === 'unless')) {
+          if (!isConstructor && !sideEffectOnly && isLast && h === 'if') {
             let [cond, thenB, ...elseB] = stmt.slice(1);
             let hasMulti = (b) => this.is(b, 'block') && b.length > 2;
             if (hasMulti(thenB) || elseB.some(hasMulti)) {
@@ -2299,7 +2315,13 @@ export class CodeGenerator {
     // Single expression
     this.sideEffectOnly = prevSEO;
     let result;
-    if (isConstructor || this.hasExplicitControlFlow(body)) result = `{ ${this.generate(body, 'statement')}; }`;
+    if (isConstructor && autoAssignments.length > 0) {
+      // Constructor with @params as a single expression — need to emit autoAssignments
+      let isSuper = Array.isArray(body) && body[0] === 'super';
+      let bodyCode = this.generate(body, 'statement');
+      let assigns = autoAssignments.map(a => `${a};`).join(' ');
+      result = isSuper ? `{ ${bodyCode}; ${assigns} }` : `{ ${assigns} ${bodyCode}; }`;
+    } else if (isConstructor || this.hasExplicitControlFlow(body)) result = `{ ${this.generate(body, 'statement')}; }`;
     else if (Array.isArray(body) && (noRetStmts.includes(body[0]) || loopStmts.includes(body[0]))) result = `{ ${this.generate(body, 'statement')}; }`;
     else if (sideEffectOnly) result = `{ ${this.generate(body, 'statement')}; return; }`;
     else result = `{ return ${this.generate(body, 'value')}; }`;
@@ -2379,34 +2401,10 @@ export class CodeGenerator {
     if (iterators.length === 1) {
       let [iterType, vars, iterable, stepOrOwn] = iterators[0];
       if (iterType === 'for-in') {
-        let step = stepOrOwn;
-        let va = Array.isArray(vars) ? vars : [vars];
-        let noVar = va.length === 0;
-        let [itemVar, indexVar] = noVar ? ['_i', null] : va;
-        let ivp = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
-          ? this.generateDestructuringPattern(itemVar) : itemVar;
-
-        if (step && step !== null) {
-          let ih = Array.isArray(iterable) && iterable[0];
-          if (ih instanceof String) ih = str(ih);
-          let isRange = ih === '..' || ih === '...';
-          if (isRange) {
-            let isExcl = ih === '...';
-            let [s, e] = iterable.slice(1);
-            code += this.indent() + `for (let ${ivp} = ${this.generate(s, 'value')}; ${ivp} ${isExcl ? '<' : '<='} ${this.generate(e, 'value')}; ${ivp} += ${this.generate(step, 'value')}) {\n`;
-          } else {
-            let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
-            let isNeg = this.is(step, '-', 1);
-            code += isNeg
-              ? this.indent() + `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${idxN} += ${stc}) {\n`
-              : this.indent() + `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${idxN} += ${stc}) {\n`;
-            this.indentLevel++;
-            if (!noVar) code += this.indent() + `const ${ivp} = ${ic}[${idxN}];\n`;
-          }
-        } else {
-          code += this.indent() + `for (const ${ivp} of ${this.generate(iterable, 'value')}) {\n`;
-        }
+        let { header, setup } = this._forInHeader(vars, iterable, stepOrOwn);
+        code += this.indent() + header + ' {\n';
         this.indentLevel++;
+        if (setup) code += this.indent() + setup + '\n';
         if (guards && guards.length > 0) {
           code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
           this.indentLevel++;
@@ -2423,155 +2421,51 @@ export class CodeGenerator {
 
   generateComprehensionAsLoop(expr, iterators, guards) {
     let code = '';
+    let guardCond = guards?.length ? guards.map(g => this.generate(g, 'value')).join(' && ') : null;
+
+    // Helper: emit the loop body with optional guard wrapping
+    let emitBody = () => {
+      if (guardCond) {
+        code += this.indent() + `if (${guardCond}) {\n`;
+        this.indentLevel++;
+        code += this.indent() + this.generate(expr, 'statement') + ';\n';
+        this.indentLevel--; code += this.indent() + '}\n';
+      } else {
+        code += this.indent() + this.generate(expr, 'statement') + ';\n';
+      }
+    };
+
     if (iterators.length === 1) {
       let [iterType, vars, iterable, stepOrOwn] = iterators[0];
 
       if (iterType === 'for-in') {
-        let step = stepOrOwn;
-        let va = Array.isArray(vars) ? vars : [vars];
-        let noVar = va.length === 0;
-        let [itemVar, indexVar] = noVar ? ['_i', null] : va;
-        let ivp = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
-          ? this.generateDestructuringPattern(itemVar) : itemVar;
-
-        if (step && step !== null) {
-          let ih = Array.isArray(iterable) && iterable[0];
-          if (ih instanceof String) ih = str(ih);
-          let isRange = ih === '..' || ih === '...';
-          if (isRange) {
-            let isExcl = ih === '...';
-            let [s, e] = iterable.slice(1);
-            code += `for (let ${ivp} = ${this.generate(s, 'value')}; ${ivp} ${isExcl ? '<' : '<='} ${this.generate(e, 'value')}; ${ivp} += ${this.generate(step, 'value')}) `;
-          } else {
-            let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
-            let isNeg = this.is(step, '-', 1);
-            let isMinus1 = isNeg && (step[1] === '1' || step[1] === 1 || str(step[1]) === '1');
-            let isPlus1 = !isNeg && (step === '1' || step === 1 || str(step) === '1');
-            if (isMinus1) code += `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${idxN}--) `;
-            else if (isPlus1) code += `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${idxN}++) `;
-            else if (isNeg) code += `for (let ${idxN} = ${ic}.length - 1; ${idxN} >= 0; ${idxN} += ${stc}) `;
-            else code += `for (let ${idxN} = 0; ${idxN} < ${ic}.length; ${idxN} += ${stc}) `;
-            code += '{\n';
-            this.indentLevel++;
-            if (!noVar) code += this.indent() + `const ${ivp} = ${ic}[${idxN}];\n`;
-          }
-          if (guards?.length) {
-            if (!isRange) code += this.indent();
-            code += '{\n'; this.indentLevel++;
-            code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
-            this.indentLevel++;
-            code += this.indent() + this.generate(expr, 'statement') + ';\n';
-            this.indentLevel--; code += this.indent() + '}\n';
-            this.indentLevel--; code += this.indent() + '}';
-          } else {
-            if (!isRange) code += this.indent();
-            code += '{\n'; this.indentLevel++;
-            code += this.indent() + this.generate(expr, 'statement') + ';\n';
-            this.indentLevel--; code += this.indent() + '}';
-          }
-          if (!isRange) { this.indentLevel--; code += '\n' + this.indent() + '}'; }
-          return code;
-        }
-
-        if (indexVar) {
-          let ic = this.generate(iterable, 'value');
-          code += `for (let ${indexVar} = 0; ${indexVar} < ${ic}.length; ${indexVar}++) `;
-          code += '{\n'; this.indentLevel++;
-          code += this.indent() + `const ${ivp} = ${ic}[${indexVar}];\n`;
-        } else {
-          code += `for (const ${ivp} of ${this.generate(iterable, 'value')}) `;
-          if (guards?.length) {
-            code += '{\n'; this.indentLevel++;
-            code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
-            this.indentLevel++;
-            code += this.indent() + this.generate(expr, 'statement') + ';\n';
-            this.indentLevel--; code += this.indent() + '}\n';
-            this.indentLevel--; code += this.indent() + '}';
-          } else {
-            code += '{\n'; this.indentLevel++;
-            code += this.indent() + this.generate(expr, 'statement') + ';\n';
-            this.indentLevel--; code += this.indent() + '}';
-          }
-          return code;
-        }
-
-        // Fall through for indexVar case
-        if (guards?.length) {
-          code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
-          this.indentLevel++;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-          this.indentLevel--; code += this.indent() + '}\n';
-        } else {
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-        }
+        let { header, setup } = this._forInHeader(vars, iterable, stepOrOwn);
+        code += header + ' {\n';
+        this.indentLevel++;
+        if (setup) code += this.indent() + setup + '\n';
+        emitBody();
         this.indentLevel--;
         code += this.indent() + '}';
         return code;
       }
 
       if (iterType === 'for-as') {
-        let va = Array.isArray(vars) ? vars : [vars];
-        let [fv] = va;
-        let ivp = ((this.is(fv, 'array') || this.is(fv, 'object')))
-          ? this.generateDestructuringPattern(fv) : fv;
-        code += `for (const ${ivp} of ${this.generate(iterable, 'value')}) `;
-        if (guards?.length) {
-          code += '{\n'; this.indentLevel++;
-          code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
-          this.indentLevel++;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-          this.indentLevel--; code += this.indent() + '}\n';
-          this.indentLevel--; code += this.indent() + '}';
-        } else {
-          code += '{\n'; this.indentLevel++;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-          this.indentLevel--; code += this.indent() + '}';
-        }
+        let { header } = this._forAsHeader(vars, iterable, stepOrOwn);
+        code += header + ' {\n';
+        this.indentLevel++;
+        emitBody();
+        this.indentLevel--;
+        code += this.indent() + '}';
         return code;
       }
 
       if (iterType === 'for-of') {
-        let va = Array.isArray(vars) ? vars : [vars];
-        let [kv, vv] = va;
-        let own = stepOrOwn;
-        let oc = this.generate(iterable, 'value');
-        code += `for (const ${kv} in ${oc}) {\n`;
+        let { header, own, vv, oc, kvp } = this._forOfHeader(vars, iterable, stepOrOwn);
+        code += header + ' {\n';
         this.indentLevel++;
-        if (own && !vv && !guards?.length) {
-          code += this.indent() + `if (!Object.hasOwn(${oc}, ${kv})) continue;\n`;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-        } else if (own && vv && guards?.length) {
-          code += this.indent() + `if (Object.hasOwn(${oc}, ${kv})) {\n`;
-          this.indentLevel++;
-          code += this.indent() + `const ${vv} = ${oc}[${kv}];\n`;
-          code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
-          this.indentLevel++;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-          this.indentLevel--; code += this.indent() + '}\n';
-          this.indentLevel--; code += this.indent() + '}\n';
-        } else if (own && vv) {
-          code += this.indent() + `if (Object.hasOwn(${oc}, ${kv})) {\n`;
-          this.indentLevel++;
-          code += this.indent() + `const ${vv} = ${oc}[${kv}];\n`;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-          this.indentLevel--; code += this.indent() + '}\n';
-        } else if (vv && guards?.length) {
-          code += this.indent() + `const ${vv} = ${oc}[${kv}];\n`;
-          code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
-          this.indentLevel++;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-          this.indentLevel--; code += this.indent() + '}\n';
-        } else if (vv) {
-          code += this.indent() + `const ${vv} = ${oc}[${kv}];\n`;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-        } else if (guards?.length) {
-          code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
-          this.indentLevel++;
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-          this.indentLevel--; code += this.indent() + '}\n';
-        } else {
-          code += this.indent() + this.generate(expr, 'statement') + ';\n';
-        }
+        if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kvp})) continue;\n`;
+        if (vv) code += this.indent() + `const ${vv} = ${oc}[${kvp}];\n`;
+        emitBody();
         this.indentLevel--;
         code += this.indent() + '}';
         return code;
@@ -2588,7 +2482,7 @@ export class CodeGenerator {
   generateIfElseWithEarlyReturns(ifStmt) {
     let [head, condition, thenBranch, ...elseBranches] = ifStmt;
     let code = '';
-    let condCode = head === 'unless' ? `!${this.generate(condition, 'value')}` : this.generate(condition, 'value');
+    let condCode = this.generate(condition, 'value');
     code += this.indent() + `if (${condCode}) {\n`;
     code += this.withIndent(() => this.generateBranchWithReturn(thenBranch));
     code += this.indent() + '}';
@@ -2738,7 +2632,7 @@ export class CodeGenerator {
     if (!generated || generated.endsWith(';')) return false;
     if (!generated.endsWith('}')) return true;
     let h = Array.isArray(stmt) ? stmt[0] : null;
-    return !['def', 'class', 'if', 'unless', 'for-in', 'for-of', 'for-as', 'while', 'until', 'loop', 'switch', 'try'].includes(h);
+    return !['def', 'class', 'if', 'for-in', 'for-of', 'for-as', 'while', 'loop', 'switch', 'try'].includes(h);
   }
 
   addSemicolon(stmt, generated) { return generated + (this.needsSemicolon(stmt, generated) ? ';' : ''); }
@@ -2765,7 +2659,7 @@ export class CodeGenerator {
         return stmts.some(s => Array.isArray(s) && ['return', 'throw', 'break', 'continue'].includes(s[0]));
       });
     }
-    if (t === 'if' || t === 'unless') {
+    if (t === 'if') {
       let [, , thenB, elseB] = body;
       return this.branchHasControlFlow(thenB) && elseB && this.branchHasControlFlow(elseB);
     }
@@ -3154,14 +3048,19 @@ function __effect(fn) {
     dependencies: new Set(),
 
     run() {
+      if (effect._cleanup) { effect._cleanup(); effect._cleanup = null; }
       for (const dep of effect.dependencies) dep.delete(effect);
       effect.dependencies.clear();
       const prev = __currentEffect;
       __currentEffect = effect;
-      try { fn(); } finally { __currentEffect = prev; }
+      try {
+        const result = fn();
+        if (typeof result === 'function') effect._cleanup = result;
+      } finally { __currentEffect = prev; }
     },
 
     dispose() {
+      if (effect._cleanup) { effect._cleanup(); effect._cleanup = null; }
       for (const dep of effect.dependencies) dep.delete(effect);
       effect.dependencies.clear();
     }