rip-lang 3.7.3 → 3.8.8

package/src/grammar/solar.rip

@@ -10,6 +10,7 @@
 import * as fs from 'fs'
 import * as path from 'path'
 import { fileURLToPath, pathToFileURL } from 'url'
+import { install as installLunar } from './lunar.rip'
 
 VERSION = '1.5.0'
 
@@ -89,9 +90,11 @@ class Generator
     # Build parser
     @timing '💥 Total time', =>
       @timing 'processGrammar'   , => @processGrammar grammar # Process grammar rules
-      @timing 'buildLRAutomaton' , => @buildLRAutomaton()     # Build LR(0) automaton
+      unless @options.rd
+        @timing 'buildLRAutomaton' , => @buildLRAutomaton()     # Build LR(0) automaton
       @timing 'processLookaheads', => @processLookaheads()    # Compute FIRST/FOLLOW and assign lookaheads
-      @timing 'buildParseTable'  , => @buildParseTable()      # Build parse table with default actions
+      unless @options.rd
+        @timing 'buildParseTable'  , => @buildParseTable()      # Build parse table with default actions
 
   # ============================================================================
   # Helper Functions
@@ -470,6 +473,7 @@ class Generator
 
   # Assign FOLLOW sets to reduction items
   _assignItemLookaheads!: ->
+    return unless @states
     for state in @states
       for item as state.reductions
         follows = @types[item.rule.type]?.follows
@@ -653,6 +657,8 @@ class Generator
     # Decoder reconstructs [{key: val}, ...] at runtime
     "(()=>{let d=[#{data.join ','}],t=[],p=0,n,o,k,a;while(p<d.length){n=d[p++];o={};k=0;a=[];while(n--)k+=d[p++],a.push(k);for(k of a)o[k]=d[p++];t.push(o)}return t})()"
 
+  # Recursive descent generation — installed by Lunar (see lunar.rip)
+
   # ============================================================================
   # Runtime Parser
   # ============================================================================
@@ -767,6 +773,8 @@ class Generator
 # Exports
 # ==============================================================================
 
+installLunar Generator
+
 export { Generator }
 
 # ==============================================================================
@@ -798,6 +806,7 @@ if isRunAsScript
         -v, --version           Show version
         -i, --info              Show grammar information
         -s, --sexpr             Show grammar as s-expression
+        -r, --rd                Generate recursive descent parser (parser-rd.js)
         -c, --conflicts         Show conflict details (use with --info)
         -o, --output <file>     Output file (default: parser.js)
 
@@ -835,7 +844,7 @@ if isRunAsScript
           console.log "     Resolution: #{conflict.resolution} (by default)"
 
     # Parse command line
-    options = {help: false, version: false, info: false, sexpr: false, conflicts: false, output: 'parser.js'}
+    options = {help: false, version: false, info: false, sexpr: false, conflicts: false, rd: false, output: 'parser.js'}
     grammarFile = null
     i = 0
 
@@ -846,6 +855,7 @@ if isRunAsScript
         when '-v', '--version'   then options.version   = true
         when '-i', '--info'      then options.info      = true
         when '-s', '--sexpr'     then options.sexpr     = true
+        when '-r', '--rd'        then options.rd        = true
         when '-c', '--conflicts' then options.conflicts = true
         when '-o', '--output'    then options.output    = process.argv[++i + 2]
         else grammarFile = arg unless arg.startsWith('-')
@@ -906,7 +916,11 @@ if isRunAsScript
       if options.info
         showStats generator
       else
-        parserCode = generator.generate()
+        if options.rd
+          options.output = 'parser-rd.js' if options.output is 'parser.js'
+          parserCode = generator.generateRD()
+        else
+          parserCode = generator.generate()
         fs.writeFileSync options.output, parserCode
         console.log "\nParser generated: #{options.output}"
 

package/src/lexer.js

@@ -220,7 +220,7 @@ let NEWLINE_RE    = /^(?:\n[^\n\S]*)+/;
 let COMMENT_RE    = /^(\s*)###([^#][\s\S]*?)(?:###([^\n\S]*)|###$)|^((?:\s*#(?!##[^#]).*)+)/;
 let CODE_RE       = /^[-=]>/;
 let REACTIVE_RE   = /^(?:~[=>]|=!)/;
-let STRING_START_RE   = /^(?:'''|"""|'|")/;
+let STRING_START_RE   = /^(?:'''\\|"""\\|'''|"""|'|")/;
 let STRING_SINGLE_RE  = /^(?:[^\\']|\\[\s\S])*/;
 let STRING_DOUBLE_RE  = /^(?:[^\\"#$]|\\[\s\S]|\#(?!\{)|\$(?!\{))*/;
 let HEREDOC_SINGLE_RE = /^(?:[^\\']|\\[\s\S]|'(?!''))*/;
@@ -627,10 +627,19 @@ export class Lexer {
   // --------------------------------------------------------------------------
 
   commentToken() {
+    // In render blocks, #word is an element ID, not a comment
+    if (this.inRenderBlock) {
+      if (/^#[a-zA-Z_]/.test(this.chunk)) {
+        let prev = this.prev();
+        if (prev && (prev[0] === 'IDENTIFIER' || prev[0] === 'PROPERTY'))
+          return 0;  // after a tag (div#main) → let # become a token for rewriter
+        let m = /^#([a-zA-Z_][\w-]*)/.exec(this.chunk);
+        if (m) { this.emit('IDENTIFIER', 'div#' + m[1]); return m[0].length; }
+      }
+      if (/^\s+#[a-zA-Z_]/.test(this.chunk)) return 0;  // let lineToken handle indentation first
+    }
     let match = COMMENT_RE.exec(this.chunk);
     if (!match) return 0;
-    // For now, consume the comment and discard it
-    // TODO: attach comments to adjacent tokens for source map support
     return match[0].length;
   }
 
@@ -779,6 +788,8 @@ export class Lexer {
     if (!m) return 0;
 
     let quote = m[0];
+    let raw = quote.length > 1 && quote.endsWith('\\');
+    let baseQuote = raw ? quote.slice(0, -1) : quote;
     let prev = this.prev();
 
     // Tag 'from' in import/export context
@@ -787,24 +798,24 @@ export class Lexer {
     }
 
     let regex;
-    switch (quote) {
+    switch (baseQuote) {
       case "'":   regex = STRING_SINGLE_RE; break;
       case '"':   regex = STRING_DOUBLE_RE; break;
       case "'''": regex = HEREDOC_SINGLE_RE; break;
       case '"""': regex = HEREDOC_DOUBLE_RE; break;
     }
 
-    let {tokens: parts, index: end} = this.matchWithInterpolations(regex, quote);
-    let heredoc = quote.length === 3;
+    let {tokens: parts, index: end} = this.matchWithInterpolations(regex, quote, baseQuote);
+    let heredoc = baseQuote.length === 3;
 
     // Heredoc indent processing
     let indent = null;
     if (heredoc) {
-      indent = this.processHeredocIndent(end, quote, parts);
+      indent = this.processHeredocIndent(end, baseQuote, parts);
     }
 
     // Merge interpolation tokens into the stream
-    this.mergeInterpolationTokens(parts, {quote, indent, endOffset: end});
+    this.mergeInterpolationTokens(parts, {quote: baseQuote, indent, endOffset: end, raw});
 
     return end;
   }
@@ -910,7 +921,7 @@ export class Lexer {
   }
 
   // Merge NEOSTRING/TOKENS into the real token stream
-  mergeInterpolationTokens(tokens, {quote, indent, endOffset}) {
+  mergeInterpolationTokens(tokens, {quote, indent, endOffset, raw}) {
     if (tokens.length > 1) {
       this.emit('STRING_START', '(', {len: quote?.length || 0, data: {quote}});
     }
@@ -939,6 +950,12 @@ export class Lexer {
           processed = processed.replace(/\n[^\S\n]*$/, '');
         }
 
+        // Raw heredocs ('''\, """\): escape only recognized JS escape sequences
+        // so \n \t \u etc. stay literal, but \s \w \d pass through unchanged
+        if (raw) {
+          processed = processed.replace(/\\([nrtbfv0\\'"`xu])/g, '\\\\$1');
+        }
+
         this.emit('STRING', `"${processed}"`, {len: val.length, data: {quote}});
       }
     }
@@ -996,8 +1013,8 @@ export class Lexer {
       let end = index + flags.length;
 
       if (parts.length === 1 || !parts.some(p => p[0] === 'TOKENS')) {
-        // Simple heregex (no interpolations)
-        let body = parts[0]?.[1] || '';
+        // Simple heregex (no interpolations) — escape unescaped / for regex literal
+        let body = (parts[0]?.[1] || '').replace(/(?<!\\)\//g, '\\/');
         this.emit('REGEX', `/${body}/${flags}`, {len: end, data: {delimiter: '///', heregex: {flags}}});
       } else {
         // Complex heregex with interpolations
@@ -1133,10 +1150,23 @@ export class Lexer {
     else if (val === '~>') tag = 'REACT_ASSIGN';
     else if (val === '=!') tag = 'READONLY_ASSIGN';
     // Merge assignment: *config = {a: 1} → Object.assign(config, {a: 1})
+    // Also supports *@ = props → Object.assign(this, props)
     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
+             (/^[a-zA-Z_$]/.test(this.chunk[1] || '') || this.chunk[1] === '@')) {
       let rest = this.chunk.slice(1);
+      // Handle *@ = ... → Object.assign(@, ...)
+      let mAt = /^@(\s*)=(?!=)/.exec(rest);
+      if (mAt) {
+        let space = mAt[1];
+        this.emit('IDENTIFIER', 'Object');
+        this.emit('.', '.');
+        let t = this.emit('PROPERTY', 'assign');
+        t.spaced = true; // trigger implicit call detection
+        this.emit('@', '@');
+        this.emit(',', ',');
+        return 1 + 1 + space.length + 1; // consume *@ =, value tokens become args
+      }
+      // Scan ahead to find "IDENTIFIER =" pattern
       let m = /^((?:(?!\s)[$\w\x7f-\uffff])+(?:\.[a-zA-Z_$][\w]*)*)(\s*)=(?!=)/.exec(rest);
       if (m) {
         let target = m[1], space = m[2];
@@ -1361,7 +1391,7 @@ export class Lexer {
   //   - Combine #id selectors: div # main → div#main
   //   - Two-way binding: value <=> username → __bind_value__: username
   //   - Event modifiers: @click.prevent: → [@click.prevent]:
-  //   - Dynamic classes: div.('card', x && 'active') → div.__cx__(...)
+  //   - Dynamic classes: div.('card', x && 'active') → div.__clsx(...)
   //   - Implicit nesting: inject -> before INDENT for template elements
   //   - Hyphenated attributes: data-foo: "x" → "data-foo": "x"
   // =========================================================================
@@ -1385,7 +1415,7 @@ export class Lexer {
       return isHtmlTag(name) || isComponent(name);
     };
 
-    let startsWithHtmlTag = (tokens, i) => {
+    let startsWithTag = (tokens, i) => {
       let j = i;
       while (j > 0) {
         let pt = tokens[j - 1][0];
@@ -1394,7 +1424,7 @@ export class Lexer {
         }
         j--;
       }
-      return tokens[j] && tokens[j][0] === 'IDENTIFIER' && isHtmlTag(tokens[j][1]);
+      return tokens[j] && tokens[j][0] === 'IDENTIFIER' && isTemplateTag(tokens[j][1]);
     };
 
     this.scanTokens(function(token, i, tokens) {
@@ -1486,7 +1516,7 @@ export class Lexer {
       if (tag === 'IDENTIFIER' || tag === 'PROPERTY') {
         let next = tokens[i + 1];
         let nextNext = tokens[i + 2];
-        if (next && next[0] === '#' && nextNext && nextNext[0] === 'PROPERTY') {
+        if (next && next[0] === '#' && nextNext && (nextNext[0] === 'PROPERTY' || nextNext[0] === 'IDENTIFIER')) {
           token[1] = token[1] + '#' + nextNext[1];
           if (nextNext.spaced) token.spaced = true;
           tokens.splice(i + 1, 2);
@@ -1533,15 +1563,15 @@ export class Lexer {
 
       // ─────────────────────────────────────────────────────────────────────
       // Dynamic classes
-      // div.('card', x && 'active') → div.__cx__('card', x && 'active')
-      // .('card') → div.__cx__('card')
+      // div.('card', x && 'active') → div.__clsx('card', x && 'active')
+      // .('card') → div.__clsx('card')
       // ─────────────────────────────────────────────────────────────────────
       if (tag === '.' && nextToken && nextToken[0] === '(') {
         let prevToken = i > 0 ? tokens[i - 1] : null;
         let prevTag = prevToken ? prevToken[0] : null;
         let atLineStart = prevTag === 'INDENT' || prevTag === 'TERMINATOR';
 
-        let cxToken = gen('PROPERTY', '__cx__', token);
+        let cxToken = gen('PROPERTY', '__clsx', token);
         nextToken[0] = 'CALL_START';
         let depth = 1;
         for (let j = i + 2; j < tokens.length && depth > 0; j++) {
@@ -1572,14 +1602,16 @@ export class Lexer {
         }
 
         let isTemplateElement = false;
+        let prevTag = i > 0 ? tokens[i - 1][0] : null;
+        let isAfterControlFlow = prevTag === 'IF' || prevTag === 'UNLESS' || prevTag === 'WHILE' || prevTag === 'UNTIL' || prevTag === 'WHEN';
 
-        if (tag === 'IDENTIFIER' && isTemplateTag(token[1])) {
+        if (tag === 'IDENTIFIER' && isTemplateTag(token[1]) && !isAfterControlFlow) {
           isTemplateElement = true;
         } else if (tag === 'PROPERTY' || tag === 'STRING' || tag === 'CALL_END' || tag === ')') {
-          isTemplateElement = startsWithHtmlTag(tokens, i);
+          isTemplateElement = startsWithTag(tokens, i);
         }
         else if (tag === 'IDENTIFIER' && i > 1 && tokens[i - 1][0] === '...') {
-          if (startsWithHtmlTag(tokens, i)) {
+          if (startsWithTag(tokens, i)) {
             let commaToken = gen(',', ',', token);
             let arrowToken = gen('->', '->', token);
             arrowToken.newLine = true;
@@ -1589,16 +1621,36 @@ export class Lexer {
         }
 
         if (isTemplateElement) {
-          let callStartToken = gen('CALL_START', '(', token);
-          let arrowToken = gen('->', '->', token);
-          arrowToken.newLine = true;
-
-          tokens.splice(i + 1, 0, callStartToken, arrowToken);
-          pendingCallEnds.push(currentIndent + 1);
-          return 3;
+          let isClassOrIdTail = tag === 'PROPERTY' && i > 0 && (tokens[i - 1][0] === '.' || tokens[i - 1][0] === '#');
+          if ((tag === 'IDENTIFIER' && isTemplateTag(token[1])) || isClassOrIdTail) {
+            // Bare tag or tag.class/tag#id (no other args): inject CALL_START -> and manage CALL_END
+            let callStartToken = gen('CALL_START', '(', token);
+            let arrowToken = gen('->', '->', token);
+            arrowToken.newLine = true;
+            tokens.splice(i + 1, 0, callStartToken, arrowToken);
+            pendingCallEnds.push(currentIndent + 1);
+            return 3;
+          } else {
+            // Tag with args: inject , -> (call wrapping handled by addImplicitBracesAndParens)
+            let commaToken = gen(',', ',', token);
+            let arrowToken = gen('->', '->', token);
+            arrowToken.newLine = true;
+            tokens.splice(i + 1, 0, commaToken, arrowToken);
+            return 3;
+          }
         }
       }
 
+      // ─────────────────────────────────────────────────────────────────────
+      // Bare component reference (PascalCase, no children, no args)
+      // Counter → Counter() so it gets treated as a component instantiation
+      // ─────────────────────────────────────────────────────────────────────
+      if (tag === 'IDENTIFIER' && isComponent(token[1]) &&
+          nextToken && (nextToken[0] === 'OUTDENT' || nextToken[0] === 'TERMINATOR')) {
+        tokens.splice(i + 1, 0, gen('CALL_START', '(', token), gen('CALL_END', ')', token));
+        return 3;
+      }
+
       return 1;
     });
   }