rip-lang 3.16.3 → 3.17.1

package/package.json

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

package/src/compiler.js

@@ -1645,15 +1645,20 @@ export class CodeEmitter {
   // no longer travels through the `.d.ts` header and the overload-interleave
   // splice (typecheck.js). Off by default — runtime / `-c` output is unchanged.
   //
+  // `node` is the type-bearing s-expression head: the function NAME for `def`,
+  // or the `->`/`=>` arrow operator for arrow functions (the lexer adapter
+  // Object.assigns each token's `.data` — including `returnType` — onto its
+  // String-wrapper, so both carry the annotation).
+  //
   // Only an EXPLICIT user annotation (`def f():: T`) is emitted, verbatim via
   // `ripToTs`. `void` is deliberately NOT synthesized for `!` functions: on an
   // async function `: void` (or any non-Promise type) is itself a TS1064, so a
   // synthesized annotation would fire a spurious error on legitimate async
   // side-effect functions once 1064 is recovered. Those keep flowing through
   // the header until a later slice handles them.
-  inlineReturnType(name) {
+  inlineReturnType(node) {
     if (!this.options.inlineTypes) return '';
-    let rt = meta(name, 'returnType');
+    let rt = meta(node, 'returnType');
     return rt ? `: ${ripToTs(rt)}` : '';
   }
 
@@ -1665,7 +1670,8 @@ export class CodeEmitter {
     let bodyCode = this.emitFunctionBody(body, params, sideEffectOnly);
     let isAsync = this.containsAwait(body);
     let isGen = this.containsYield(body);
-    let fn = `${isAsync ? 'async ' : ''}function${isGen ? '*' : ''}(${paramList}) ${bodyCode}`;
+    let ret = this.inlineReturnType(sexpr?.[0]);
+    let fn = `${isAsync ? 'async ' : ''}function${isGen ? '*' : ''}(${paramList})${ret} ${bodyCode}`;
     return context === 'value' ? `(${fn})` : fn;
   }
 
@@ -1674,7 +1680,13 @@ export class CodeEmitter {
     if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(body)) params = ['it'];
     let sideEffectOnly = sexpr.isVoid || false;
     let paramList = this.emitParamList(params);
-    let isSingle = params.length === 1 && typeof params[0] === 'string' &&
+    // RFC 12 phase 2: an inline return type forces parenthesized params —
+    // `x: R => …` is invalid TS, only `(x): R => …`. Latent until fat-arrow
+    // return types are expressible (the `=>` annotation-vs-operator grammar
+    // ambiguity is a separate slice); `ret` is `''` today, so output is
+    // unchanged.
+    let ret = this.inlineReturnType(sexpr?.[0]);
+    let isSingle = !ret && params.length === 1 && typeof params[0] === 'string' &&
                    !paramList.includes('=') && !paramList.includes('...') &&
                    !paramList.includes('[') && !paramList.includes('{');
     let paramSyntax = isSingle ? paramList : `(${paramList})`;
@@ -1688,18 +1700,18 @@ export class CodeEmitter {
         if (exprHead !== 'return' && !STMT_ONLY.has(exprHead)) {
           let code = this.emit(expr, 'value');
           if (code[0] === '{') code = `(${code})`;
-          return `${prefix}${paramSyntax} => ${code}`;
+          return `${prefix}${paramSyntax}${ret} => ${code}`;
         }
       }
       if (!Array.isArray(body) || body[0] !== 'block') {
         let code = this.emit(body, 'value');
         if (code[0] === '{') code = `(${code})`;
-        return `${prefix}${paramSyntax} => ${code}`;
+        return `${prefix}${paramSyntax}${ret} => ${code}`;
       }
     }
 
     let bodyCode = this.emitFunctionBody(body, params, sideEffectOnly);
-    return `${prefix}${paramSyntax} => ${bodyCode}`;
+    return `${prefix}${paramSyntax}${ret} => ${bodyCode}`;
   }
 
   emitReturn(head, rest, context, sexpr) {

package/src/dts.js

@@ -157,9 +157,11 @@ export function emitTypes(tokens, sexpr = null, source = '', schemaBehavior = nu
     let dd = 0;
     while (j < tokens.length) {
       let dt = tokens[j];
-      if (dt[0] === '(' || dt[0] === '[' || dt[0] === '{') dd++;
-      if (dt[0] === ')' || dt[0] === ']' || dt[0] === '}') {
-        if (dd === 0) break; // closing bracket of enclosing structure
+      if (dt[0] === '(' || dt[0] === '[' || dt[0] === '{' ||
+          dt[0] === 'CALL_START' || dt[0] === 'PARAM_START' || dt[0] === 'INDEX_START') dd++;
+      if (dt[0] === ')' || dt[0] === ']' || dt[0] === '}' ||
+          dt[0] === 'CALL_END' || dt[0] === 'PARAM_END' || dt[0] === 'INDEX_END') {
+        if (dd === 0) break; // closing bracket of the enclosing param list / pattern
         dd--;
       }
       if (dd === 0 && dt[1] === ',') break;
@@ -348,29 +350,34 @@ export function emitTypes(tokens, sexpr = null, source = '', schemaBehavior = nu
         continue;
       }
 
-      // Destructured object parameter: { a, b }
+      // Destructured object parameter: { a, b }. An EXTERNAL type annotation
+      // `({a, b}: {a: T, b: U})` lands on the closing `}` token's data.type and
+      // takes precedence over a type reconstructed from in-pattern annotations.
       if (tok[0] === '{') {
         depth--; // undo the depth++ from nesting tracker above
         let result = collectDestructuredObj(tokens, j);
         j = result.endJ;
-        if (result.hasAnyType) {
-          params.push(`${result.patternStr}: ${result.typeStr}`);
-        } else {
-          params.push(result.patternStr);
-        }
+        let ext = tokens[j - 1]?.data?.type;
+        let patternStr = result.patternStr;
+        // A whole-pattern default (`{…}: T = {}`) makes the param optional.
+        if (tokens[j]?.[0] === '=') { patternStr += '?'; j = skipDefault(tokens, j); }
+        if (ext) params.push(`${patternStr}: ${tsType(ext)}`);
+        else if (result.hasAnyType) params.push(`${patternStr}: ${result.typeStr}`);
+        else params.push(patternStr);
         continue;
       }
 
-      // Destructured array parameter: [ a, b ]
+      // Destructured array parameter: [ a, b ] (external type lands on `]`).
       if (tok[0] === '[') {
         depth--; // undo the depth++ from nesting tracker above
         let result = collectDestructuredArr(tokens, j);
         j = result.endJ;
-        if (result.hasAnyType) {
-          params.push(`${result.patternStr}: ${result.typeStr}`);
-        } else {
-          params.push(result.patternStr);
-        }
+        let ext = tokens[j - 1]?.data?.type;
+        let patternStr = result.patternStr;
+        if (tokens[j]?.[0] === '=') { patternStr += '?'; j = skipDefault(tokens, j); }
+        if (ext) params.push(`${patternStr}: ${tsType(ext)}`);
+        else if (result.hasAnyType) params.push(`${patternStr}: ${result.typeStr}`);
+        else params.push(patternStr);
         continue;
       }
 

package/src/lexer.js

@@ -893,6 +893,13 @@ export class Lexer {
         else if (tk[0] === 'SHIFT' && tk[1] === '>>>') depth += 3;
         else if (tk[0] === 'COMPARE' && tk[1] === '<') depth--;
         if (depth === 0 && tk[0] === 'TYPE_ANNOTATION') return false;
+        // A single `:` return type (Rip 3.17) — `…): Generic<…>` — closes a
+        // generic just like `::` does. Recognize it when the `:` directly
+        // follows a param-list close (mirrors the `tagParameters` acceptance).
+        if (depth === 0 && tk[0] === ':') {
+          let pv = this.tokens[k - 1];
+          if (pv && (pv[0] === ')' || pv[0] === 'PARAM_END' || pv[0] === 'CALL_END')) return false;
+        }
         if (depth === 0 && tk[0] === 'IDENTIFIER' && tk[1] === 'type') return false;
         if (tk[0] === 'INTERFACE') return false;
         if (tk[0] === 'TERMINATOR' || tk[0] === 'INDENT' || tk[0] === 'OUTDENT') {
@@ -1534,7 +1541,10 @@ export class Lexer {
                    (tg === 'COMPARE' && tk[1] === '<')) {
           depth--;
         } else if (depth === 0) {
-          if (tg === 'TYPE_ANNOTATION') {
+          // A return-type annotation sits between the param `)` and the arrow.
+          // Accept both `::` (TYPE_ANNOTATION) and a single `:` (Rip 3.17) as
+          // the marker, but only when it directly follows the param-list `)`.
+          if (tg === 'TYPE_ANNOTATION' || tg === ':') {
             if (j > 0 && this.tokens[j - 1][0] === ')') found = j - 1;
             break;
           }
@@ -1545,6 +1555,25 @@ export class Lexer {
       }
       if (found < 0) return this.tagDoIife();
       closeIdx = found;
+    } else {
+      // The token before the arrow is `)`. Normally that's the param-list
+      // close — but it can also close a PARENTHESIZED return type:
+      // `(x):: (R) =>`. Disambiguate by finding this `)`'s matching `(`; if a
+      // `TYPE_ANNOTATION` (`::`) precedes that `(` and a `)` precedes the `::`,
+      // this group is the return type and the real param close is that earlier
+      // `)`. (A bare `(x) =>` has no `::` before its `(`, so it's unchanged.)
+      let d = 0, op = -1;
+      for (let k = closeIdx; k >= 0; k--) {
+        let tg = this.tokens[k][0];
+        if (tg === ')' || tg === 'CALL_END' || tg === 'PARAM_END') d++;
+        else if (tg === '(' || tg === 'CALL_START' || tg === 'PARAM_START') {
+          if (--d === 0) { op = k; break; }
+        }
+      }
+      if (op > 1 && this.tokens[op - 1][0] === 'TYPE_ANNOTATION' &&
+          this.tokens[op - 2]?.[0] === ')') {
+        closeIdx = op - 2;
+      }
     }
 
     let i = closeIdx;

package/src/typecheck.js

@@ -11,6 +11,7 @@
 //   type errors mapped back to Rip source positions.
 
 import { Compiler, getStdlibCode } from './compiler.js';
+import { Lexer } from './lexer.js';
 import { STDLIB_TYPE_DECLS } from './stdlib.js';
 import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERFACE, SIGNAL_FN, COMPUTED_INTERFACE, COMPUTED_FN, EFFECT_FN, ripDestructuredNames } from './dts.js';
 import './schema/loader-server.js';   // registers full schema runtime provider
@@ -367,18 +368,31 @@ export function walkRoutesDir(routesDir) {
 // Detect type annotations (:: followed by space or =) ignoring comments,
 // string literals, and prototype syntax (Class::method).
 export function hasTypeAnnotations(source) {
+  // Type aliases / interfaces don't lower to TYPE_ANNOTATION tokens, so detect
+  // them by name from the source first (cheap, and robust mid-edit).
   let inHeredoc = false;
-  return source.split('\n').some(line => {
-    // Track heredoc boundaries (''' or """)
+  const hasTypeDecl = source.split('\n').some(line => {
     const ticks = (line.match(/'''|"""/g) || []);
     for (const t of ticks) inHeredoc = !inHeredoc;
     if (inHeredoc) return false;
-    // Strip comment
-    line = line.replace(/#.*$/, '');
-    // Strip string literals (single and double quoted)
-    line = line.replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)*'/g, "''");
-    return /::[ \t=]/.test(line) || /(?:^|export\s+)type\s+[A-Z]/.test(line.trimStart());
+    line = line.replace(/#.*$/, '').trimStart();
+    return /^(?:export\s+)?(?:type\s+[A-Z]|interface\s)/.test(line);
   });
+  if (hasTypeDecl) return true;
+  // Type ANNOTATIONS — single-colon (Rip 3.17) or `::` — both lower to a
+  // TYPE_ANNOTATION token after the rewriter runs. Tokenizing is the accurate
+  // test (a string scan can't tell `x: T = v` from the object `{x: T}`); fall
+  // back to the literal `::` heuristic if tokenization fails on a partial buffer.
+  try {
+    // The rewriter consumes type annotations into `.data.type` /
+    // `.data.returnType` on the annotated token (they don't survive as
+    // TYPE_ANNOTATION tokens), so detect that metadata.
+    for (const t of new Lexer().tokenize(source, { rewrite: true }))
+      if (t.data && (t.data.type || t.data.returnType)) return true;
+    return false;
+  } catch {
+    return /::[ \t=]/.test(source.replace(/#.*$/gm, ''));
+  }
 }
 
 export function countLines(str) {
@@ -1153,6 +1167,82 @@ function replaceFnParams(line, newParams) {
   return depth === 0 ? line.slice(0, idx + 1) + newParams + line.slice(i - 1) : line;
 }
 
+// Skip a string/template/regex literal starting at `s[i]` (the opening quote),
+// returning the index just past the closing quote. Honors backslash escapes.
+function skipStringLiteral(s, i) {
+  const q = s[i];
+  i++;
+  while (i < s.length) {
+    if (s[i] === '\\') { i += 2; continue; }
+    if (s[i] === q) return i + 1;
+    i++;
+  }
+  return i;
+}
+
+// Recognize a compiled module-scope fat-arrow assignment for `name`:
+//   NAME = (params) => …        NAME = ident => …
+//   NAME = async (params) => …  NAME = async ident => …
+// Returns null when `line` is not such an assignment, else
+// `{ hasInlineReturn }` — whether an inline `: T` return annotation already
+// sits between the params and `=>`. (There is no generator-arrow form; thin
+// arrows lower to `= function(` and are matched separately.) A structural
+// scan, not a regex: generated param lists can contain nested parens, default
+// values, and string literals, so the params span and the implementation `=>`
+// must be located by balanced, string-aware scanning.
+function analyzeArrowImpl(line, name) {
+  const pre = new RegExp(`^\\s*${name}\\s*=\\s*`).exec(line);
+  if (!pre) return null;
+  const s = line;
+  let i = pre[0].length;
+  const skipWs = () => { while (i < s.length && (s[i] === ' ' || s[i] === '\t')) i++; };
+  skipWs();
+  // `async ` is the modifier — but only when real params follow. A bare
+  // identifier param named `async` (`NAME = async => …`) is not the modifier;
+  // don't consume it as one (it would otherwise mis-parse as no params).
+  if (s.startsWith('async', i) && /\s/.test(s[i + 5] || '')) {
+    let k = i + 5;
+    while (k < s.length && (s[k] === ' ' || s[k] === '\t')) k++;
+    if (!(s[k] === '=' && s[k + 1] === '>')) i = k;
+  }
+
+  // Parameter list: `(...)` (balanced, string-aware) or a bare identifier.
+  if (s[i] === '(') {
+    let depth = 0;
+    for (; i < s.length; i++) {
+      const c = s[i];
+      if (c === '"' || c === "'" || c === '`') { i = skipStringLiteral(s, i) - 1; continue; }
+      if (c === '(') depth++;
+      else if (c === ')' && --depth === 0) { i++; break; }
+    }
+    if (depth !== 0) return null;
+  } else if (/[A-Za-z_$]/.test(s[i] || '')) {
+    while (i < s.length && /[\w$]/.test(s[i])) i++;
+  } else {
+    return null;
+  }
+  skipWs();
+
+  // Optional inline return type `: T` between the params and `=>`. Latent
+  // today (fat-arrow return types aren't expressible yet), but recognized so
+  // the self-sufficiency check stays correct once they are.
+  let hasInlineReturn = false;
+  if (s[i] === ':') {
+    hasInlineReturn = true;
+    let depth = 0;
+    for (; i < s.length; i++) {
+      const c = s[i];
+      if (c === '"' || c === "'" || c === '`') { i = skipStringLiteral(s, i) - 1; continue; }
+      if (c === '=' && s[i + 1] === '>' && depth === 0) break;
+      if (c === '(' || c === '[' || c === '{' || c === '<') depth++;
+      else if (c === ')' || c === ']' || c === '}' || c === '>') depth--;
+    }
+    skipWs();
+  }
+
+  return (s[i] === '=' && s[i + 1] === '>') ? { hasInlineReturn } : null;
+}
+
 // Depth-aware split of a parameter list on top-level commas. Respects
 // nested parens, brackets, braces, and angle brackets so callback types
 // like `(fn: (x: number) => void)` and generic types like `Map<K, V>`
@@ -1422,22 +1512,26 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
       const injections = [];
       const moved = new Set();
       for (const fn of fnSigs) {
-        // Match the impl in either of two shapes:
+        // Match the impl in one of three shapes:
         //   1. top-level: `function NAME(`, `function NAME<`,
         //      `async function NAME(`, `export function NAME(`
-        //   2. bare-name arrow assignment: `NAME = function(`,
+        //   2. thin-arrow assignment: `NAME = function(`,
         //      `NAME = async function(`, `NAME = function*(`
-        // Pattern (2) is how Rip emits arrow assignments at module
-        // scope: `name = (...) -> ...` becomes `name = function(...) {…}`.
-        // We deliberately do NOT match `obj.NAME = function(`: the DTS
-        // emits `declare function NAME(...)` only for module-scope,
-        // bare-name arrow assignments. A property-style match would
-        // pick up an unrelated `obj.NAME = ...` line that happens to
-        // share the function name and apply the wrong signature there.
+        //      (`name = (...) -> ...` lowers to `name = function(...) {…}`)
+        //   3. fat-arrow assignment: `NAME = (...) => …`, `NAME = x => …`,
+        //      `NAME = async (...) => …` (`name = (...) => ...`). Without this
+        //      the own-file `declare function NAME` survives next to the
+        //      `let NAME` / `NAME = … =>` binding and TS reports TS2630
+        //      ("cannot assign to NAME because it is a function") — visible in
+        //      the editor shadow even when CLI `rip check` masks it.
+        // We deliberately do NOT match `obj.NAME = …`: the DTS emits
+        // `declare function NAME(...)` only for module-scope, bare-name
+        // assignments. A property-style match would pick up an unrelated
+        // `obj.NAME = ...` line sharing the name and apply the wrong signature.
         const topLevelPat = new RegExp(`^(?:export\\s+)?(?:async\\s+)?function\\s+${fn.name}\\s*[(<]`);
         const arrowAssignPat = new RegExp(`^\\s*${fn.name}\\s*=\\s*(?:async\\s+)?function\\s*\\*?\\s*\\(`);
         for (let j = 0; j < cl.length; j++) {
-          if (topLevelPat.test(cl[j]) || arrowAssignPat.test(cl[j])) {
+          if (topLevelPat.test(cl[j]) || arrowAssignPat.test(cl[j]) || analyzeArrowImpl(cl[j], fn.name)) {
             injections.push({ codeLine: j, sig: fn.sig });
             moved.add(fn.idx);
             break;
@@ -1536,16 +1630,60 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
           const nm = inj.sig.match(/function\s+(\w+)/)?.[1];
           if (nm) sigCountByName.set(nm, (sigCountByName.get(nm) || 0) + 1);
         }
+        // A `{…}`/`[…]` destructuring parameter can't be reliably typed inline:
+        // an EXTERNAL type (`({a}: {a: T})`) is attached to the closing-bracket
+        // token and lost to the AST-based inline emitter, while an in-pattern
+        // type reconstructs fine. Rather than split those cases, force the param
+        // copy from the `.d.ts` signature (which carries the correct type for
+        // both forms via dts.js) whenever the param list opens a pattern.
+        function paramListHasPattern(line) {
+          const open = line.indexOf('(');
+          if (open < 0) return false;
+          let depth = 0, atParamStart = false;
+          for (let k = open; k < line.length; k++) {
+            const c = line[k];
+            if (c === '(') { depth++; if (depth === 1) atParamStart = true; continue; }
+            if (c === ')') { if (--depth === 0) return false; continue; }
+            if (depth !== 1) continue;
+            if (c === ',') { atParamStart = true; continue; }
+            if (c === ' ' || c === '\t') continue;
+            if (atParamStart && (c === '{' || c === '[')) return true;
+            atParamStart = false;
+          }
+          return false;
+        }
         function isSelfSufficient(inj) {
           const nm = inj.sig.match(/function\s+(\w+)/)?.[1];
           if (!nm || sigCountByName.get(nm) !== 1) return false;
           if (extractTypeParams(inj.sig)) return false;
           const impl = cl[inj.codeLine];
+          if (paramListHasPattern(impl)) return false;
+          // Arrow detection is authoritative and runs first: it's a precise
+          // structural scan, so a fat-arrow line can't be misread by the
+          // function-form brace heuristic below (which would otherwise pick a
+          // nested object-literal `{` on an expression body). A fat-arrow
+          // assignment (`NAME = (params) => …`) emits its params inline, so it
+          // is self-sufficient when it carries an inline return type, OR when
+          // the header has no return type to preserve. Fat-arrow return types
+          // aren't expressible yet, so the header never carries one — moving it
+          // (no copy) is complete and lossless. Once they are, an arrow that
+          // lacks the inline return while the header has one is NOT self-
+          // sufficient and falls through to the copy fallback (return preserved).
+          const arrow = analyzeArrowImpl(impl, nm);
+          if (arrow) {
+            if (arrow.hasInlineReturn) return true;
+            if (!hasExplicitReturn(inj.sig)) return true;
+            return false;
+          }
+          // Function-form impl (`def`, thin-arrow `= function(`): self-sufficient
+          // when an inline return type sits between the params `)` and the `{`.
           const braceIdx = impl.lastIndexOf('{');
-          if (braceIdx < 0) return false;
-          const head = impl.slice(0, braceIdx);
-          const afterParen = head.slice(head.lastIndexOf(')') + 1).trim();
-          return afterParen.startsWith(':');
+          if (braceIdx >= 0) {
+            const head = impl.slice(0, braceIdx);
+            const afterParen = head.slice(head.lastIndexOf(')') + 1).trim();
+            if (afterParen.startsWith(':')) return true;
+          }
+          return false;
         }
 
         // First pass: copy typed params AND return types from signatures to
@@ -1609,7 +1747,11 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
         // would force it to `any`. Functions with any untyped param would fire
         // TS7006 twice (once on the injected sig, once on the impl) at the same
         // source position — skip the injection so the user sees a single error.
-        const overloads = injections.filter(inj => !isSelfSufficient(inj) && hasExplicitReturn(inj.sig) && !hasUntypedParam(inj.sig));
+        // Destructuring-param functions get their full typed signature copied
+        // onto the implementation (above); an extra overload signature is
+        // redundant and, for a rename pattern (`{name: userName}`), its
+        // body-less form makes `userName` an "unused renaming" (TS2842). Skip it.
+        const overloads = injections.filter(inj => !isSelfSufficient(inj) && hasExplicitReturn(inj.sig) && !hasUntypedParam(inj.sig) && !paramListHasPattern(cl[inj.codeLine]));
 
         // Adjust reverseMap: each overload injection shifts subsequent code lines down by 1.
         // Compare against the original genLine (not genLine + offset) because bottom-up