rip-lang 3.0.0 → 3.0.2

package/package.json

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

package/src/grammar/grammar.rip

@@ -6,7 +6,7 @@
 # Each rule maps a pattern of tokens/types to an s-expression action.
 #
 # Action format:
-#   - Numbers (1, 2, 3...) reference matched symbols by position
+#   - Numbers (1, 2, ...3) reference matched symbols by position
 #   - ...N spreads the array at position N
 #   - String literals become s-expression nodes: '["if", 2, 3]'
 #   - Default action (no action given) returns position 1
@@ -15,10 +15,8 @@
 #   - Removed :: and ?:: (prototype access) — reserved for future type annotations
 #   - Removed INDEX_SOAK — use ES6 optional indexing (?.[i]) instead
 #   - Removed FUNC_EXIST / OptFuncExist — use ES6 optional call (?.(args)) instead
-#   - Removed Expression ? (existence check) — use ?? instead
 #   - Renamed FORFROM → FORAS, for-from → for-as (for x as iterable)
 #   - Simplified Invocation (no soak variants)
-#
 # ==============================================================================
 
 o = (pattern, action, options) ->
@@ -796,6 +794,9 @@ grammar =
     o '- Expression'          , '["-", 2]', prec: 'UNARY_MATH'
     o '+ Expression'          , '["+", 2]', prec: 'UNARY_MATH'
 
+    # Postfix existence check: expr? → (expr != null)
+    o 'Value ?'               , '["?", 1]'
+
     # Await
     o 'AWAIT Expression'            , '["await", 2]'
     o 'AWAIT INDENT Object OUTDENT' , '["await", 3]'
@@ -856,7 +857,7 @@ operators = """
   right       DO_IIFE
   left        . ?.
   left        CALL_START CALL_END
-  nonassoc    ++ --
+  nonassoc    ++ -- ?
   right       UNARY DO
   right       AWAIT
   right       **

package/src/grammar/solar.rip

@@ -53,7 +53,7 @@ class Item
 
 # LR State: A set of items with transitions to other states
 class State
-  constructor: (items...) ->
+  constructor: (...items) ->
     @id           = null           # state number (assigned later)
     @items        = new Set(items) # kernel and closure items
     @transitions  = new Map        # symbol → next state

package/src/lexer.js

@@ -643,6 +643,12 @@ export class Lexer {
 
     // If we're in an unfinished expression, suppress the newline
     if (this.isUnfinished()) {
+      // Exception: comma at a lower indent continues the outer call, not the block
+      if (size < this.indent && /^\s*,/.test(this.chunk) && !UNFINISHED.has(this.prevTag())) {
+        this.outdentTo(size, indent.length);
+        if (this.prevTag() === 'TERMINATOR') this.tokens.pop();
+        return indent.length;
+      }
       return indent.length;
     }
 
@@ -1070,6 +1076,8 @@ export class Lexer {
     else if (SHIFT.has(val))           tag = 'SHIFT';
     // Spaced ? → SPACE? (ternary)
     else if (val === '?' && prev?.spaced) tag = 'SPACE?';
+    // ?[ and ?( without dot → treat as optional chaining (?.)
+    else if (val === '?' && (this.chunk[1] === '[' || this.chunk[1] === '(')) tag = '?.';
     // Call/index context (ES6 optional chaining only)
     else if (prev) {
       if (val === '(' && !prev.spaced && CALLABLE.has(prev[0])) {
@@ -1184,12 +1192,11 @@ export class Lexer {
     let starter = null;
     let indent = null;
     let outdent = null;
-
     let condition = (token, i) => {
       return token[1] !== ';' && SINGLE_CLOSERS.has(token[0]) &&
         !(token[0] === 'TERMINATOR' && EXPRESSION_CLOSE.has(this.tokens[i + 1]?.[0])) &&
         !(token[0] === 'ELSE' && starter !== 'THEN') ||
-        token[0] === ',' && (starter === '->' || starter === '=>') ||
+        token[0] === ',' && (starter === '->' || starter === '=>') && !this.commaInImplicitCall(i) ||
         CALL_CLOSERS.has(token[0]) && (this.tokens[i - 1]?.newLine || this.tokens[i - 1]?.[0] === 'OUTDENT');
     };
 
@@ -1491,6 +1498,27 @@ export class Lexer {
     }
   }
 
+  // Scan backward from comma to see if it's inside an implicit function call
+  commaInImplicitCall(i) {
+    let levels = 0;
+    for (let j = i - 1; j >= 0; j--) {
+      let tag = this.tokens[j][0];
+      if (EXPRESSION_END.has(tag)) { levels++; continue; }
+      if (EXPRESSION_START.has(tag)) {
+        if (tag === 'INDENT') return false;
+        levels--;
+        if (levels < 0) return false;
+        continue;
+      }
+      if (levels > 0) continue;
+      if (IMPLICIT_FUNC.has(tag) && this.tokens[j].spaced) {
+        let nt = this.tokens[j + 1]?.[0];
+        return IMPLICIT_CALL.has(nt) || (nt === '...' && IMPLICIT_CALL.has(this.tokens[j + 2]?.[0]));
+      }
+    }
+    return false;
+  }
+
   looksObjectish(j) {
     if (!this.tokens[j]) return false;
     if (this.tokens[j]?.[0] === '@' && this.tokens[j + 2]?.[0] === ':') return true;