rip-lang 2.8.3 → 2.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "2.8.3",
+  "version": "2.8.5",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/src/compiler.js

@@ -2582,8 +2582,20 @@ export class CodeGenerator {
       const stmts = this.withIndent(() => this.formatStatements(statements));
       return `{\n${stmts.join('\n')}\n${this.indent()}}`;
     }
-    // In value context, just format statements
-    return this.formatStatements(statements, context);
+    // In value context, handle sequences like (a; b; c)
+    if (statements.length === 0) return 'undefined';
+    if (statements.length === 1) return this.generate(statements[0], context);
+    // Check if last statement is control flow (break/continue/return/throw)
+    const last = statements[statements.length - 1];
+    const lastIsControl = Array.isArray(last) && ['break', 'continue', 'return', 'throw'].includes(last[0]);
+    if (lastIsControl) {
+      // Control flow needs block form: { stmt1; stmt2; break; }
+      const bodyParts = statements.map(s => this.addSemicolon(s, this.generate(s, 'statement')));
+      return `{\n${this.withIndent(() => bodyParts.map(p => this.indent() + p).join('\n'))}\n${this.indent()}}`;
+    }
+    // Use comma operator for value sequences: (a, b, c) returns c
+    const parts = statements.map(s => this.generate(s, 'value'));
+    return `(${parts.join(', ')})`;
   }
 
   /**
@@ -2750,16 +2762,8 @@ export class CodeGenerator {
     for (const whenClause of whens) {
       const [, test, body] = whenClause;
 
-      // Handle multiple test values (when 1, 2, 3)
-      // Need to distinguish:
-      //   ["-", "1"] → single s-expression (unary minus)
-      //   ["a", "b"] → multiple string/number values
-      // Check if first element is an operator (s-expression) or a value (list)
-      const firstTest = normalize(Array.isArray(test) && test.length > 0 ? test[0] : null);
-      const isTestList = Array.isArray(test) && test.length > 0 &&
-                        typeof firstTest === 'string' &&
-                        !firstTest.match(/^[-+*\/%<>=!&|^~]$|^(typeof|delete|new|not|await|yield)$/);
-      const tests = isTestList ? test : [test];
+      // SimpleArgs always produces an array of test values
+      const tests = test;
 
       for (const t of tests) {
         const tValue = normalize(t);
@@ -5099,20 +5103,35 @@ export class CodeGenerator {
     // Don't unwrap if there are operators or multiple parts outside the parens
     while (code.startsWith('(') && code.endsWith(')')) {
       // Check if these parens wrap the entire expression
-      let depth = 0;
+      let parenDepth = 0;
+      let bracketDepth = 0;  // Track [] and {}
       let canUnwrap = true;
+      let hasCommaAtDepth1 = false;
 
       for (let i = 0; i < code.length; i++) {
-        if (code[i] === '(') depth++;
-        if (code[i] === ')') depth--;
+        const ch = code[i];
+        if (ch === '(') parenDepth++;
+        if (ch === ')') parenDepth--;
+        if (ch === '[' || ch === '{') bracketDepth++;
+        if (ch === ']' || ch === '}') bracketDepth--;
+
+        // Check for comma operator at depth 1 (inside outer parens, not inside [] or {})
+        if (ch === ',' && parenDepth === 1 && bracketDepth === 0) {
+          hasCommaAtDepth1 = true;
+        }
 
         // If we hit depth 0 before the end, parens don't wrap everything
-        if (depth === 0 && i < code.length - 1) {
+        if (parenDepth === 0 && i < code.length - 1) {
           canUnwrap = false;
           break;
         }
       }
 
+      // Don't unwrap comma operator expressions - the parens are required
+      if (hasCommaAtDepth1) {
+        canUnwrap = false;
+      }
+
       if (canUnwrap) {
         code = code.slice(1, -1);
       } else {
@@ -5459,10 +5478,13 @@ export class CodeGenerator {
       const whenClause = whens[i];
       const [, test, body] = whenClause;
 
+      // SimpleArgs now always produces array; for if-chain we use first (typically only) condition
+      const condition = Array.isArray(test) ? test[0] : test;
+
       if (i === 0) {
-        code += `if (${this.generate(test, 'value')}) {\n`;
+        code += `if (${this.generate(condition, 'value')}) {\n`;
       } else {
-        code += ` else if (${this.generate(test, 'value')}) {\n`;
+        code += ` else if (${this.generate(condition, 'value')}) {\n`;
       }
       this.indentLevel++;
 

package/src/grammar/grammar.rip

@@ -585,10 +585,10 @@ grammar =
     o 'Elision TERMINATOR'
   ]
 
-  # Simple argument lists for switch statements
+  # Simple argument lists for switch statements (always produces array)
   SimpleArgs: [
-    o 'Expression'
-    o 'SimpleArgs , Expression', 'Array.isArray($1) ? [...$1, $3] : [$1, $3]' # Prevent splitting Strings into chars
+    o 'Expression'             , '[$1]'         # Single: wrap in array
+    o 'SimpleArgs , Expression', '[...$1, $3]'  # Multiple: spread + add
   ]
 
   # Try/catch/finally exception handling
@@ -612,10 +612,10 @@ grammar =
     o 'THROW INDENT Object OUTDENT', '["throw", 3]'
   ]
 
-  # Parenthesized expressions - unwrap single-element Bodies
+  # Parenthesized expressions - unwrap single-element Bodies, wrap multiple in block
   Parenthetical: [
-    o '( Body )'               , '$2.length === 1 ? $2[0] : $2'
-    o '( INDENT Body OUTDENT )', '$3.length === 1 ? $3[0] : $3'
+    o '( Body )'               , '$2.length === 1 ? $2[0] : ["block", ...$2]'
+    o '( INDENT Body OUTDENT )', '$3.length === 1 ? $3[0] : ["block", ...$3]'
   ]
 
   # While loop conditions (consolidated)

package/src/lexer.js

@@ -2579,7 +2579,7 @@ Rewriter = (function() {
             // Close implicit objects such as:
             // return a: 1, b: 2 unless true
             // But NOT for || or && which should stay inside objects
-            } else if (inImplicitObject() && !isLogicalOp && sameLine && tag !== 'TERMINATOR' && prevTag !== ':' && !((tag === 'POST_IF' || tag === 'FOR' || tag === 'WHILE' || tag === 'UNTIL') && startsLine && implicitObjectContinues(i + 1))) {
+            } else if (inImplicitObject() && !isLogicalOp && sameLine && tag !== 'TERMINATOR' && prevTag !== ':' && !((tag === 'POST_IF' || tag === 'POST_UNLESS' || tag === 'FOR' || tag === 'WHILE' || tag === 'UNTIL') && startsLine && implicitObjectContinues(i + 1))) {
               endImplicitObject();
             // Close implicit objects when at end of line, line didn't end with a comma
             // and the implicit object didn't start the line or the next line doesn't look like
@@ -3281,7 +3281,7 @@ IMPLICIT_UNSPACED_CALL = ['+', '-'];
 
 // Tokens that always mark the end of an implicit call for single-liners.
 // Includes || and && so that `read 'body' or ''` parses as `read('body') || ''`
-IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR', '||', '&&'];
+IMPLICIT_END = ['POST_IF', 'POST_UNLESS', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR', '||', '&&'];
 
 // Literals that trigger comma insertion before arrows: get '/path' -> ... becomes get('/path', -> ...)
 IMPLICIT_COMMA_BEFORE_ARROW = ['STRING', 'STRING_END', 'REGEX', 'REGEX_END', 'NUMBER', 'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', ']', '}'];

package/src/parser.js

@@ -11,10 +11,10 @@ const parserInstance = {
     switch (rule) {
       case 1: return ["program"];
       case 2: return ["program", ...$[$0]];
-      case 3: case 61: case 128: case 193: case 212: case 235: case 267: case 281: case 285: case 344: case 350: return [$[$0]];
-      case 4: case 129: case 194: case 213: case 236: case 268: return [...$[$0-2], $[$0]];
+      case 3: case 61: case 128: case 193: case 212: case 235: case 267: case 281: case 285: case 289: case 344: case 350: return [$[$0]];
+      case 4: case 129: case 194: case 213: case 236: case 268: case 290: return [...$[$0-2], $[$0]];
       case 5: case 63: case 288: return $[$0-1];
-      case 6: case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 47: case 48: case 55: case 56: case 57: case 58: case 59: case 66: case 67: case 71: case 72: case 73: case 76: case 77: case 78: case 83: case 88: case 89: case 90: case 91: case 94: case 97: case 98: case 99: case 100: case 101: case 123: case 124: case 125: case 126: case 132: case 136: case 137: case 138: case 139: case 141: case 142: case 170: case 171: case 172: case 173: case 174: case 175: case 176: case 177: case 178: case 179: case 180: case 181: case 217: case 219: case 221: case 240: case 243: case 272: case 273: case 274: case 276: case 289: case 309: case 342: case 358: case 360: return $[$0];
+      case 6: case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 47: case 48: case 55: case 56: case 57: case 58: case 59: case 66: case 67: case 71: case 72: case 73: case 76: case 77: case 78: case 83: case 88: case 89: case 90: case 91: case 94: case 97: case 98: case 99: case 100: case 101: case 123: case 124: case 125: case 126: case 132: case 136: case 137: case 138: case 139: case 141: case 142: case 170: case 171: case 172: case 173: case 174: case 175: case 176: case 177: case 178: case 179: case 180: case 181: case 217: case 219: case 221: case 240: case 243: case 272: case 273: case 274: case 276: case 309: case 342: case 358: case 360: return $[$0];
       case 30: return ["def", $[$0-4], $[$0-2], $[$0]];
       case 31: return ["def", $[$0-1], [], $[$0]];
       case 32: return ["state", $[$0-2], $[$0]];
@@ -142,7 +142,6 @@ const parserInstance = {
       case 279: return [...$[$0-2], ...$[$0-1]];
       case 280: return [...$[$0-5], ...$[$0-4], ...$[$0-2], ...$[$0-1]];
       case 284: return [...$[$0]];
-      case 290: return Array.isArray($[$0-2]) ? [...$[$0-2], $[$0]] : [$[$0-2], $[$0]];
       case 291: return ["try", $[$0]];
       case 292: return ["try", $[$0-1], $[$0]];
       case 293: return ["try", $[$0-2], $[$0]];
@@ -151,8 +150,8 @@ const parserInstance = {
       case 297: return [null, $[$0]];
       case 298: return ["throw", $[$0]];
       case 299: return ["throw", $[$0-1]];
-      case 300: return $[$0-1].length === 1 ? $[$0-1][0] : $[$0-1];
-      case 301: return $[$0-2].length === 1 ? $[$0-2][0] : $[$0-2];
+      case 300: return $[$0-1].length === 1 ? $[$0-1][0] : ["block", ...$[$0-1]];
+      case 301: return $[$0-2].length === 1 ? $[$0-2][0] : ["block", ...$[$0-2]];
       case 302: return ["while", $[$0]];
       case 303: return ["while", $[$0-2], $[$0]];
       case 304: return ["until", $[$0]];