rip-lang 3.14.5 → 3.15.0

package/src/compiler.js

@@ -11,8 +11,12 @@
 import { Lexer } from './lexer.js';
 import { parser } from './parser.js';
 import { installComponentSupport } from './components.js';
-import { emitTypes, emitEnum } from './types.js';
-import { installSchemaSupport } from './schema.js';
+// Type emission is CLI/editor-only. types-emit.js registers itself via
+// setTypesEmitter() at module load. The browser never imports types-emit,
+// so _typesEmitter stays null and .d.ts output is silently skipped.
+let _typesEmitter = null;
+export function setTypesEmitter(fn) { _typesEmitter = fn; }
+import { installSchemaSupport } from '@rip-lang/schema';
 import { SourceMapGenerator } from './sourcemaps.js';
 import { RipError, toRipError } from './error.js';
 
@@ -2045,7 +2049,22 @@ export class CodeEmitter {
   emitComprehension(head, rest, context) {
     let [expr, iterators, guards] = rest;
     if (context === 'statement') return this.emitComprehensionAsLoop(expr, iterators, guards);
-    if (this.comprehensionTarget) return this.emitComprehensionWithTarget(expr, iterators, guards, this.comprehensionTarget);
+    if (this.comprehensionTarget) {
+      // Consume-and-clear: the auto-return-loop logic sets comprehensionTarget
+      // expecting ONE consumer (the direct value-context comprehension being
+      // routed to the named target). Without clearing here, nested
+      // comprehensions inside this comprehension's body (call args, RHS
+      // expressions) would inherit the target and skip their own IIFE,
+      // producing malformed JS or wrong semantics. The body's own emit calls
+      // see comprehensionTarget = null and correctly produce IIFEs.
+      let target = this.comprehensionTarget;
+      this.comprehensionTarget = null;
+      try {
+        return this.emitComprehensionWithTarget(expr, iterators, guards, target);
+      } finally {
+        this.comprehensionTarget = target;
+      }
+    }
 
     // Enclosed: expr, iterators (iterable expressions), guards
     let hasAwait = this.containsAwait(expr) || iterators.some(i => this.containsAwait(i)) || guards.some(g => this.containsAwait(g));
@@ -2614,6 +2633,21 @@ export class CodeEmitter {
               code += this.indent() + this.addSemicolon(stmt, this.emit(stmt, 'statement')) + '\n';
               return;
             }
+            // Auto-return-loop: only for-in/for-of/for-as auto-collect into
+            // _result, because emitForIn/emitForOf/emitForAs at value-context
+            // wrap themselves in a comprehension that consumes
+            // comprehensionTarget. `loop` and `while` have no such wrapping —
+            // emitLoop/emitWhile just emit `while(...) { body }` and any
+            // comprehensionTarget set here would LEAK into nested
+            // expression-context comprehensions inside the body (causing
+            // them to be routed to the wrong target and skip their own
+            // IIFE). Loops with explicit `return X` inside their body
+            // already work correctly; emit them as plain statements.
+            let isCollectibleLoop = h === 'for-in' || h === 'for-of' || h === 'for-as';
+            if (!isCollectibleLoop) {
+              code += this.indent() + this.addSemicolon(stmt, this.emit(stmt, 'statement')) + '\n';
+              return;
+            }
             code += this.indent() + 'const _result = [];\n';
             this.comprehensionTarget = '_result';
             let saved = this._skipCompTargetInit;
@@ -3689,7 +3723,7 @@ export class Compiler {
 
     // If only terminators remain (type-only source), emit types and return early
     if (tokens.every(t => t[0] === 'TERMINATOR')) {
-      if (typeTokens) dts = emitTypes(typeTokens, ['program'], source);
+      if (typeTokens && _typesEmitter) dts = _typesEmitter(typeTokens, ['program'], source);
       return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {} };
     }
 
@@ -3759,6 +3793,11 @@ export class Compiler {
       skipDataPart: this.options.skipDataPart,
       stubComponents: this.options.stubComponents,
       reactiveVars: this.options.reactiveVars,
+      // Schema runtime mode: 'browser' / 'validate' / 'server' / 'migration'.
+      // Default 'migration' covers the common case (CLI, server, tests) where
+      // the user might call any schema feature including .toSQL(). The browser
+      // bundle build script overrides to 'browser' for size reduction.
+      schemaMode: this.options.schemaMode,
       sourceMap,
     });
     let code = generator.compile(sexpr);
@@ -3766,15 +3805,28 @@ export class Compiler {
     let map = sourceMap ? sourceMap.toJSON() : null;
     let reverseMap = sourceMap ? sourceMap.toReverseMap() : null;
     if (map && this.options.sourceMap === 'inline') {
-      let b64 = typeof Buffer !== 'undefined' ? Buffer.from(map).toString('base64') : btoa(map);
+      // map is already a JSON string (sourceMaps.toJSON() stringifies). UTF-8
+      // safe encode: btoa() only handles Latin-1, so pre-encode non-ASCII via
+      // TextEncoder before base64 in browsers. Bun's Buffer handles utf-8
+      // directly. Source files containing emoji, em-dashes, accented chars,
+      // etc. would otherwise break with `Failed to execute 'btoa'`.
+      let b64;
+      if (typeof Buffer !== 'undefined') {
+        b64 = Buffer.from(map, 'utf8').toString('base64');
+      } else {
+        const bytes = new TextEncoder().encode(map);
+        let bin = '';
+        for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+        b64 = btoa(bin);
+      }
       code += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
     } else if (map && this.options.filename) {
       code += `\n//# sourceMappingURL=${this.options.filename}.js.map`;
     }
 
     // Step 5: Emit .d.ts from annotated tokens + parsed s-expression
-    if (typeTokens) {
-      dts = emitTypes(typeTokens, sexpr, source);
+    if (typeTokens && _typesEmitter) {
+      dts = _typesEmitter(typeTokens, sexpr, source);
     }
 
     return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
@@ -3791,10 +3843,36 @@ export class Compiler {
 installComponentSupport(CodeEmitter, Lexer);
 
 // =============================================================================
-// Type Support (enum generator)
+// Enum Codegen (CodeEmitter method)
 // =============================================================================
+// `enum` blocks compile to a runtime JavaScript object that maps both
+// forward (key → value) and reverse (value → key). This is real codegen,
+// not type machinery, so it lives with the rest of the emitter dispatch.
+
+CodeEmitter.prototype.emitEnum = function emitEnum(head, rest, context) {
+  let [name, body] = rest;
+  let enumName = name?.valueOf?.() ?? name;
+
+  let pairs = [];
+  if (Array.isArray(body)) {
+    let items = body[0] === 'block' ? body.slice(1) : [body];
+    for (let item of items) {
+      if (Array.isArray(item)) {
+        if (item[0]?.valueOf?.() === '=') {
+          let key = item[1]?.valueOf?.() ?? item[1];
+          let val = item[2]?.valueOf?.() ?? item[2];
+          pairs.push([key, val]);
+        }
+      }
+    }
+  }
+
+  if (pairs.length === 0) return `const ${enumName} = {}`;
 
-CodeEmitter.prototype.emitEnum = emitEnum;
+  let forward = pairs.map(([k, v]) => `${k}: ${v}`).join(', ');
+  let reverse = pairs.map(([k, v]) => `${v}: "${k}"`).join(', ');
+  return `const ${enumName} = {${forward}, ${reverse}}`;
+};
 
 // =============================================================================
 // Schema Support (prototype installation)

package/src/grammar/grammar.rip

@@ -808,7 +808,7 @@ grammar =
   # Schema
   # ============================================================================
   # `schema [:kind] INDENT ... OUTDENT` is parsed entirely by the schema
-  # sub-parser at lexer-rewrite time (src/schema.js). The rewriter emits
+  # sub-parser at lexer-rewrite time (packages/schema/src/schema.js). The rewriter emits
   # a synthetic SCHEMA_BODY token whose .data carries the full descriptor
   # (kind, entries, per-entry loc). The main grammar only sees these two
   # terminals, which keeps schema body syntax (`name! type`, `@directive`,

package/src/grammar/solar.rip

@@ -154,7 +154,6 @@ class Generator
       for handle in handles
         [symbols, action, precedence] = @_parseHandle handle
 
-        # Add symbols to grammar
         addSymbol symbol for symbol in symbols
 
         # Process semantic actions

package/src/lexer.js

@@ -40,7 +40,7 @@
 // ==========================================================================
 
 import { installTypeSupport } from './types.js';
-import { installSchemaSupport } from './schema.js';
+import { installSchemaSupport } from '@rip-lang/schema';
 
 // ==========================================================================
 // Token Category Sets
@@ -174,6 +174,15 @@ let TAGGABLE = new Set(['IDENTIFIER', 'PROPERTY', ')', 'CALL_END', ']', 'INDEX_E
 // Control flow tokens that don't end implicit calls/objects
 let CONTROL_IN_IMPLICIT = new Set(['IF', 'TRY', 'FINALLY', 'CATCH', 'CLASS', 'SWITCH', 'COMPONENT', 'FOR']);
 
+// Tokens that complete an expression value. Used to detect postfix-position
+// for keywords that exist in both prefix and postfix forms (FOR has no
+// dedicated POST_FOR token like POST_IF, so we infer it from context).
+let VALUE_END_TAGS = new Set([
+  'IDENTIFIER', 'PROPERTY', 'NUMBER', 'STRING', 'STRING_END', 'REGEX', 'REGEX_END',
+  ')', 'CALL_END', ']', 'INDEX_END', '}', 'MAP_END', 'PICK_END',
+  'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', 'SUPER', 'THIS', '@', 'SYMBOL',
+]);
+
 // Single-liner keywords that get implicit INDENT/OUTDENT
 let SINGLE_LINERS = new Set(['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN']);
 
@@ -1782,8 +1791,21 @@ export class Lexer {
         i += 1;
       };
 
-      // Don't end implicit on INDENT for control flow inside implicit
-      if ((inImplicitCall() || inImplicitObject()) && CONTROL_IN_IMPLICIT.has(tag)) {
+      // Don't end implicit on INDENT for control flow inside implicit.
+      //
+      // Special case: FOR is the only entry in CONTROL_IN_IMPLICIT that can
+      // appear in postfix position (no POST_FOR token exists, unlike
+      // POST_IF / POST_UNLESS). When FOR follows a value-completing token
+      // on the same line (e.g. `addSymbol s for s in xs`), it's a postfix
+      // comprehension that should END the implicit call so the comprehension
+      // wraps the call rather than becoming the call's argument. Detect
+      // postfix FOR by: not at the start of a new line, AND the previous
+      // token is a value-completing token (IDENTIFIER, ), ], literal, etc.).
+      // Prefix FOR (after `:`, `=`, `->`, comma, etc.) keeps the existing
+      // CONTROL behaviour. Falling through lets the IMPLICIT_END handler
+      // below close the implicit call.
+      let isPostfixFor = tag === 'FOR' && !token.newLine && VALUE_END_TAGS.has(prevTag);
+      if ((inImplicitCall() || inImplicitObject()) && CONTROL_IN_IMPLICIT.has(tag) && !isPostfixFor) {
         stack.push(['CONTROL', i, {ours: true}]);
         return forward(1);
       }

package/src/parser.js

@@ -256,16 +256,16 @@ const parserInstance = {
     }
   },
   parse(input) {
-    let EOF, TERROR, action, errStr, expected, len, lex, lexer, loc, locs, newState, p, parseTable, preErrorSymbol, r, recovering, rv, sharedState, state, stk, symbol, tokenLen, tokenLine, tokenLoc, tokenText, vals;
+    let EOF, TERROR, action, errStr, expected, k, len, lex, lexer, loc, locs, newState, p, parseTable, preErrorSymbol, r, recovering, rv, sharedState, state, stk, symbol, tokenLen, tokenLine, tokenLoc, tokenText, v, vals;
     [stk, vals, locs] = [[0], [null], []];
     [parseTable, tokenText, tokenLine, tokenLen, recovering] = [this.parseTable, "", 0, 0, 0];
     [TERROR, EOF] = [2, 1];
     lexer = Object.create(this.lexer);
     sharedState = { ctx: {} };
-    for (const k in this.ctx) {
+    for (let k in this.ctx) {
       if (!Object.hasOwn(this.ctx, k))
         continue;
-      const v = this.ctx[k];
+      let v = this.ctx[k];
       sharedState.ctx[k] = v;
     }
     lexer.setInput(input, sharedState.ctx);
@@ -294,7 +294,7 @@ const parserInstance = {
         if (!recovering)
           expected = (() => {
             const result = [];
-            for (const p in parseTable[state]) {
+            for (let p in parseTable[state]) {
               if (!Object.hasOwn(parseTable[state], p))
                 continue;
               if (this.tokenNames[p] && p > TERROR)

package/src/typecheck.js

@@ -11,8 +11,9 @@
 //   type errors mapped back to Rip source positions.
 
 import { Compiler, getStdlibCode } from './compiler.js';
-import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERFACE, SIGNAL_FN, COMPUTED_INTERFACE, COMPUTED_FN, EFFECT_FN } from './types.js';
-import { hasSchemas } from './schema.js';
+import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERFACE, SIGNAL_FN, COMPUTED_INTERFACE, COMPUTED_FN, EFFECT_FN } from './types-emit.js';
+import { hasSchemas } from '@rip-lang/schema';
+import '@rip-lang/schema/loader-server';   // registers full schema runtime provider
 import { createRequire } from 'module';
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { resolve, relative, dirname } from 'path';