rip-lang 3.6.1 → 3.7.0

package/src/grammar/grammar.rip

@@ -564,6 +564,7 @@ grammar =
     o 'UnlessBlock'
     o 'Statement POST_IF Expression'     , '["if", 3, [1]]'
     o 'Expression POST_IF Expression'    , '["if", 3, [1]]'
+    o 'Expression POST_IF Expression ELSE INDENT Expression OUTDENT', '["?:", 3, 1, 6]'
     o 'Statement POST_UNLESS Expression' , '["unless", 3, [1]]'
     o 'Expression POST_UNLESS Expression', '["unless", 3, [1]]'
   ]
@@ -620,8 +621,9 @@ grammar =
   ]
 
   Loop: [
-    o 'LOOP Block'     , '["loop", 2]'
-    o 'LOOP Expression', '["loop", [2]]'
+    o 'LOOP Block'            , '["loop", 2]'
+    o 'LOOP Expression'       , '["loop", [2]]'
+    o 'LOOP Expression Block' , '["loop-n", 2, 3]'
   ]
 
   # For loops
@@ -797,6 +799,10 @@ grammar =
     o 'EXPORT Identifier = Expression'                     , '["export", ["=", 2, 4]]'
     o 'EXPORT Identifier = TERMINATOR Expression'          , '["export", ["=", 2, 5]]'
     o 'EXPORT Identifier = INDENT Expression OUTDENT'      , '["export", ["=", 2, 5]]'
+    o 'EXPORT ReactiveAssign'                              , '["export", 2]'
+    o 'EXPORT ComputedAssign'                              , '["export", 2]'
+    o 'EXPORT ReadonlyAssign'                              , '["export", 2]'
+    o 'EXPORT ReactAssign'                                 , '["export", 2]'
     o 'EXPORT DEFAULT Expression'                          , '["export-default", 3]'
     o 'EXPORT DEFAULT INDENT Object OUTDENT'               , '["export-default", 4]'
     o 'EXPORT EXPORT_ALL FROM String'                      , '["export-all", 4]'
@@ -878,6 +884,9 @@ grammar =
     o 'Expression ?? Expression'      , '["??", 1, 3]'
     o 'Expression !? Expression'      , '["!?", 1, 3]'  # Otherwise (undefined-only coalescing)
 
+    # Pipe
+    o 'Expression PIPE Expression'    , '["|>", 1, 3]'
+
     # Relational
     o 'Expression RELATION Expression', '[2, 1, 3]'     # in, of, instanceof
 
@@ -918,6 +927,7 @@ operators = """
   left        |
   left        &&
   left        ||
+  left        PIPE
   right       SPACE?
   nonassoc    INDENT OUTDENT
   right       YIELD

package/src/lexer.js

@@ -127,7 +127,7 @@ let IMPLICIT_UNSPACED_CALL = new Set(['+', '-']);
 // Tokens that end an implicit call
 let IMPLICIT_END = new Set([
   'POST_IF', 'POST_UNLESS', 'FOR', 'WHILE', 'UNTIL',
-  'WHEN', 'BY', 'LOOP', 'TERMINATOR', '||', '&&',
+  'WHEN', 'BY', 'LOOP', 'TERMINATOR', '||', '&&', 'PIPE',
 ]);
 
 // Tokens that trigger implicit comma insertion before arrows
@@ -214,7 +214,7 @@ let UNARY_MATH = new Set(['!', '~']);
 // conflict with ?. (optional chaining), ?? (nullish), ?.( and ?.[
 let IDENTIFIER_RE = /^(?!\d)((?:(?!\s)[$\w\x7f-\uffff])+(?:!|[?](?![.?[(]))?)([^\n\S]*:(?![=:]))?/;
 let NUMBER_RE     = /^0b[01](?:_?[01])*n?|^0o[0-7](?:_?[0-7])*n?|^0x[\da-f](?:_?[\da-f])*n?|^\d+(?:_\d+)*n|^(?:\d+(?:_\d+)*)?\.?\d+(?:_\d+)*(?:e[+-]?\d+(?:_\d+)*)?/i;
-let OPERATOR_RE   = /^(?:<=>|::=|::|[-=]>|~>|~=|:=|=!|===|!==|!\?|\?\?|=~|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>*\/%])\2=?|\?\.?|\.{2,3})/;
+let OPERATOR_RE   = /^(?:<=>|::=|::|[-=]>|~>|~=|:=|=!|===|!==|!\?|\?\?|=~|\|>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>*\/%])\2=?|\?\.?|\.{2,3})/;
 let WHITESPACE_RE = /^[^\n\S]+/;
 let NEWLINE_RE    = /^(?:\n[^\n\S]*)+/;
 let COMMENT_RE    = /^(\s*)###([^#][\s\S]*?)(?:###([^\n\S]*)|###$)|^((?:\s*#(?!##[^#]).*)+)/;
@@ -441,7 +441,7 @@ export class Lexer {
     let match = IDENTIFIER_RE.exec(this.chunk);
     if (!match) return 0;
 
-    let [input, id, colon] = match;
+    let [, id, colon] = match;
     let idLen = id.length;
     let data = {};
     let tag;
@@ -487,8 +487,8 @@ export class Lexer {
     }
 
     // 'do super' shorthand
-    if (id === 'do' && /^(\s*super)(?!\(\))/.test(this.chunk.slice(3))) {
-      let m = /^(\s*super)(?!\(\))/.exec(this.chunk.slice(3));
+    let m;
+    if (id === 'do' && (m = /^(\s*super)(?!\(\))/.exec(this.chunk.slice(3)))) {
       this.emit('SUPER', 'super');
       this.emit('CALL_START', '(');
       this.emit('CALL_END', ')');
@@ -1071,6 +1071,20 @@ export class Lexer {
     // Arrow functions → tag parameters
     if (CODE_RE.test(val)) this.tagParameters();
 
+    // Method assignment: x .= trim() → x = x.trim()
+    if (val === '=' && prev && prev[1] === '.' && !prev.spaced) {
+      let target = this.tokens[this.tokens.length - 2];
+      if (target && (target[0] === 'IDENTIFIER' || target[0] === 'PROPERTY' || target[0] === ')' || target[0] === ']')) {
+        prev[0] = '=';
+        prev[1] = '=';
+        // Insert target clone + '.' after the '='
+        let targetClone = tok(target[0], target[1], { pre: 0, row: target[2], col: target[3], len: target[4] });
+        let dot = tok('.', '.', { pre: 0, row: this.row, col: this.col, len: 1 });
+        this.tokens.push(targetClone, dot);
+        return val.length;
+      }
+    }
+
     // Compound assignment merging: ||= &&= ??=
     if (prev && (val === '=' || COMPOUND_ASSIGN.has(val))) {
       if (val === '=' && (prev[1] === '||' || prev[1] === '&&' || prev[1] === '??') && !prev.spaced) {
@@ -1094,8 +1108,17 @@ export class Lexer {
       this.seenFor = this.seenImport = this.seenExport = false;
       tag = 'TERMINATOR';
     }
+    // Pipe operator
+    else if (val === '|>') tag = 'PIPE';
     // Type operators
     else if (val === '::=') tag = 'TYPE_ALIAS';
+    else if (val === '::' && /^[a-zA-Z_$]/.test(this.chunk[2] || '')) {
+      // Prototype access: String::trim → String.prototype.trim
+      this.emit('.', '.');
+      this.emit('PROPERTY', 'prototype');
+      this.emit('.', '.');
+      return 2;
+    }
     else if (val === '::')  tag = 'TYPE_ANNOTATION';
     // Reactive operators
     else if (val === '~=') tag = 'COMPUTED_ASSIGN';
@@ -1103,6 +1126,31 @@ export class Lexer {
     else if (val === '<=>') tag = 'BIND';
     else if (val === '~>') tag = 'REACT_ASSIGN';
     else if (val === '=!') tag = 'READONLY_ASSIGN';
+    // Merge assignment: *config = {a: 1} → Object.assign(config, {a: 1})
+    else if (val === '*' && (!prev || prev[0] === 'TERMINATOR' || prev[0] === 'INDENT' || prev[0] === 'OUTDENT') &&
+             /^[a-zA-Z_$]/.test(this.chunk[1] || '')) {
+      // Scan ahead to find "IDENTIFIER =" pattern
+      let rest = this.chunk.slice(1);
+      let m = /^((?:(?!\s)[$\w\x7f-\uffff])+(?:\.[a-zA-Z_$][\w]*)*)(\s*)=(?!=)/.exec(rest);
+      if (m) {
+        let target = m[1], space = m[2];
+        this.emit('IDENTIFIER', 'Object');
+        this.emit('.', '.');
+        this.emit('PROPERTY', 'assign');
+        this.emit('CALL_START', '(');
+        // Emit target — handle dotted paths like el.style
+        let parts = target.split('.');
+        this.emit('IDENTIFIER', parts[0]);
+        for (let i = 1; i < parts.length; i++) {
+          this.emit('.', '.');
+          this.emit('PROPERTY', parts[i]);
+        }
+        this.emit(',', ',');
+        let comma = this.prev();
+        comma.mergeClose = true; // mark for rewriter to insert CALL_END
+        return 1 + target.length + space.length + 1; // consume *target =
+      }
+    }
     // Export all
     else if (val === '*' && prev?.[0] === 'EXPORT') tag = 'EXPORT_ALL';
     // Operator classification
@@ -1185,6 +1233,7 @@ export class Lexer {
     this.tagPostfixConditionals();
     this.addImplicitBracesAndParens();
     this.addImplicitCallCommas();
+    this.closeMergeAssignments();
     return this.tokens;
   }
 
@@ -1788,6 +1837,29 @@ export class Lexer {
     }
   }
 
+  // Close merge assignments: find marked commas and insert CALL_END at expression end
+  closeMergeAssignments() {
+    let tokens = this.tokens;
+    for (let i = 0; i < tokens.length; i++) {
+      if (!tokens[i].mergeClose) continue;
+      // Scan forward to find where the value expression ends
+      let depth = 0;
+      for (let j = i + 1; j < tokens.length; j++) {
+        let tag = tokens[j][0];
+        if (tag === '(' || tag === '[' || tag === '{' || tag === 'CALL_START' || tag === 'INDEX_START' || tag === 'INDENT') depth++;
+        if (tag === ')' || tag === ']' || tag === '}' || tag === 'CALL_END' || tag === 'INDEX_END' || tag === 'OUTDENT') depth--;
+        if (depth < 0 || (depth === 0 && tag === 'TERMINATOR')) {
+          tokens.splice(j, 0, gen('CALL_END', ')', tokens[j - 1]));
+          break;
+        }
+        if (j === tokens.length - 1) {
+          tokens.splice(j + 1, 0, gen('CALL_END', ')', tokens[j]));
+          break;
+        }
+      }
+    }
+  }
+
   // Scan backward from comma to see if it's inside an implicit function call
   commaInImplicitCall(i) {
     let levels = 0;