rip-lang 2.9.1 → 2.9.2

package/package.json

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

package/src/grammar/grammar.rip

@@ -4,7 +4,7 @@
 
 o = (pattern, action, options) ->
   pattern = pattern.trim().replace /\s{2,}/g, ' '
-  [pattern, action ? 1, options]
+  [pattern, action ?? 1, options]
 
 mode = 'sexp'
 

package/src/grammar/solar.rip

@@ -105,7 +105,7 @@ class Generator
 
   dedent: (s, indent) ->
     m = s.match /^[ \t]+(?=\S)/gm
-    i = Math.min ...(m ? []).map (x) => x.length
+    i = Math.min ...(m ?? []).map (x) => x.length
     s = s.replace(///^[ \t]{#{i}}///gm, '').trim()
     s = s.replace /^/gm, indent if indent
     s

package/src/lexer.js

@@ -2062,7 +2062,6 @@ Rewriter = (function() {
       this.closeOpenCalls();
       this.closeOpenIndexes();
       this.normalizeLines();
-      this.convertLegacyExistential();
       this.convertPostfixSpreadRest();
       this.tagPostfixConditionals();
       this.addImplicitBracesAndParens();
@@ -3030,64 +3029,6 @@ Rewriter = (function() {
       });
     }
 
-    // =========================================================================
-    // BACKWARDS COMPATIBILITY / TRANSITION SUPPORT
-    // =========================================================================
-    // Convert legacy CoffeeScript existential operator syntax to Rip's nullish
-    // coalescing operator. In CoffeeScript, "SPACE?" (a question mark with a
-    // space before it, e.g., "x ? y") was used as an existential operator.
-    // Rip uses ES6's "??" for this purpose instead.
-    //
-    // This rewriter converts standalone "SPACE?" tokens (those NOT part of
-    // ternary expressions) into "??" operators to ease migration of old code.
-    //
-    // Examples:
-    //   x ? y        →  x ?? y     (legacy existential, converted)
-    //   x ? y : z    →  x ? y : z  (ternary, left unchanged)
-    //
-    // NOTE: This is for COMPATIBILITY and TRANSITION purposes only.
-    // New code should use "??" explicitly instead of relying on this conversion.
-    // =========================================================================
-    convertLegacyExistential() {
-      return this.scanTokens(function(token, i, tokens) {
-        var colonFound, j, nestLevel, ref, tag;
-        // Only process SPACE? tokens
-        if (token[0] !== 'SPACE?') {
-          return 1;
-        }
-        // Look ahead to determine if this is part of a ternary expression
-        // A ternary has the pattern: Expression SPACE? Expression : Expression
-        // If we find a ':' at the same nesting level, it's a ternary
-        colonFound = false;
-        nestLevel = 0;
-        for (j = i + 1; j < tokens.length; j++) {
-          tag = tokens[j][0];
-          // Track nesting level (parentheses, brackets, braces)
-          if (ref = tag, indexOf.call(EXPRESSION_START, ref) >= 0) {
-            nestLevel++;
-          } else if (ref = tag, indexOf.call(EXPRESSION_END, ref) >= 0) {
-            nestLevel--;
-          }
-          // Found colon at same level = it's a ternary operator
-          if (tag === ':' && nestLevel === 0) {
-            colonFound = true;
-            break;
-          }
-          // Hit statement boundary without finding colon = not a ternary
-          if (nestLevel === 0 && (tag === 'TERMINATOR' || tag === 'INDENT' || tag === 'OUTDENT')) {
-            break;
-          }
-        }
-        // No colon found = legacy existential operator, convert to ??
-        if (!colonFound) {
-          token[0] = '??';
-          token[1] = '??';
-        }
-        // Otherwise leave as SPACE? for ternary handling
-        return 1;
-      });
-    }
-
     // =========================================================================
     // BACKWARDS COMPATIBILITY / TRANSITION SUPPORT
     // =========================================================================