rip-lang 3.13.91 → 3.13.93

package/src/typecheck.js

@@ -33,14 +33,55 @@ export function countLines(str) {
 export function toVirtual(p) { return p + '.ts'; }
 export function fromVirtual(p) { return p.endsWith('.rip.ts') ? p.slice(0, -3) : p; }
 
+// Patch uninitialized, untyped variables with inferred types from their
+// first assignment. This makes `let total; total = count + ratio;` behave
+// like `let total: number;` — so a later `total = "string"` is caught.
+// Called by both the LSP and the CLI type-checker to keep them aligned.
+export function patchUninitializedTypes(ts, service, compiledEntries) {
+  const program = service.getProgram();
+  if (!program) return;
+  const checker = program.getTypeChecker();
+  for (const [filePath] of compiledEntries) {
+    const sf = program.getSourceFile(toVirtual(filePath));
+    if (!sf) continue;
+    const uninitialized = new Map();
+    for (const stmt of sf.statements) {
+      if (ts.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations) {
+          if (!decl.initializer && !decl.type && ts.isIdentifier(decl.name)) {
+            const sym = checker.getSymbolAtLocation(decl.name);
+            if (sym) uninitialized.set(decl.name.text, sym);
+          }
+        }
+      }
+      if (ts.isExpressionStatement(stmt) && ts.isBinaryExpression(stmt.expression) &&
+          stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+          ts.isIdentifier(stmt.expression.left)) {
+        const name = stmt.expression.left.text;
+        const sym = uninitialized.get(name);
+        if (sym) {
+          const rhsType = checker.getTypeAtLocation(stmt.expression.right);
+          sym.flags |= ts.SymbolFlags.Transient;
+          sym.links = { type: rhsType };
+          uninitialized.delete(name);
+        }
+      }
+    }
+  }
+}
+
 // TS error codes to skip — Rip resolves modules differently and
 // treats async return types transparently.
 export const SKIP_CODES = new Set([
   2300, // Duplicate identifier (DTS declarations coexist with compiled class bodies)
   2304, // Cannot find name
   2307, // Cannot find module
+  2389, // Function implementation name must match overload (DTS + compiled body)
+  2391, // Function implementation is missing (DTS overload sigs separated from implementations)
   2393, // Duplicate function implementation
+  2394, // Overload signature not compatible with implementation (untyped compiled params)
   2451, // Cannot redeclare block-scoped variable
+  2567, // Enum declarations can only merge with namespace or other enum (DTS + compiled body)
   1064, // Return type of async function must be Promise
   2582, // Cannot find name 'test' (test runner globals)
   2593, // Cannot find name 'describe' (test runner globals)
@@ -94,26 +135,120 @@ export function compileForCheck(filePath, source, compiler) {
   // Ensure every file is treated as a module (not a global script)
   if (!/\bexport\b/.test(code) && !/\bimport\b/.test(code)) code += '\nexport {};\n';
 
-  const tsContent = (hasTypes ? dts + '\n' : '') + code;
-  const headerLines = hasTypes ? countLines(dts + '\n') : 1;
+  // Interleave function overload signatures from DTS header into the code
+  // section, immediately before their implementations. TypeScript requires
+  // overload signatures adjacent to the implementation — without this, TS
+  // reports error 2391 ("Function implementation is missing or not immediately
+  // following the declaration"). Moving signatures into the code also enables
+  // proper call-site type checking of function parameters.
+  let headerDts = dts;
+  if (hasTypes && dts && code) {
+    const dl = dts.split('\n');
+    const cl = code.split('\n');
+    const fnSigs = [];
+    for (let i = 0; i < dl.length; i++) {
+      const m = dl[i].match(/^(?:export\s+)?(?:declare\s+)?function\s+(\w+)/);
+      if (m) fnSigs.push({ name: m[1], sig: dl[i], idx: i });
+    }
+    if (fnSigs.length > 0) {
+      const injections = [];
+      const moved = new Set();
+      for (const fn of fnSigs) {
+        const pat = new RegExp(`^(?:export\\s+)?(?:async\\s+)?function\\s+${fn.name}\\s*[(<]`);
+        for (let j = 0; j < cl.length; j++) {
+          if (pat.test(cl[j])) {
+            injections.push({ codeLine: j, sig: fn.sig });
+            moved.add(fn.idx);
+            break;
+          }
+        }
+      }
+      if (injections.length > 0) {
+        injections.sort((a, b) => a.codeLine - b.codeLine);
+        // Adjust reverseMap: each injection shifts subsequent code lines down by 1
+        if (result.reverseMap) {
+          for (const [, entry] of result.reverseMap) {
+            let offset = 0;
+            for (const inj of injections) {
+              if (inj.codeLine <= entry.genLine + offset) offset++;
+            }
+            entry.genLine += offset;
+          }
+        }
+        // Insert signatures bottom-up to preserve indices.
+        // Strip 'declare ' — signatures must be non-ambient to match implementations.
+        for (let k = injections.length - 1; k >= 0; k--) {
+          cl.splice(injections[k].codeLine, 0, injections[k].sig.replace(/^declare /, ''));
+        }
+        code = cl.join('\n');
+        // Rebuild header DTS without the moved function signatures
+        headerDts = dl.filter((_, i) => !moved.has(i)).join('\n').trimEnd() + '\n';
+      }
+    }
+  }
+
+  // Annotate reactive/readonly/computed const assignments with their declared
+  // types from the DTS header, and remove the corresponding `declare const`
+  // from the header. This enables TypeScript to check initializer values
+  // against type annotations: `const x: Signal<number> = __state("oops")`
+  // produces a real type error, whereas two separate declarations
+  // (`declare const x: Signal<number>` + `const x = __state("oops")`)
+  // only produce a duplicate-identifier error (2451), which is suppressed.
+  if (hasTypes && headerDts && code) {
+    const dl = headerDts.split('\n');
+    const cl = code.split('\n');
+    const constTypes = new Map();
+
+    for (let i = 0; i < dl.length; i++) {
+      const m = dl[i].match(/^(?:export\s+)?declare\s+const\s+(\w+):\s+(.+);$/);
+      if (m) constTypes.set(m[1], { type: m[2], idx: i });
+    }
+
+    if (constTypes.size > 0) {
+      const movedDts = new Set();
+
+      for (let j = 0; j < cl.length; j++) {
+        const cm = cl[j].match(/^((?:export\s+)?const\s+)(\w+)(\s*=\s*)/);
+        if (cm && constTypes.has(cm[2])) {
+          const entry = constTypes.get(cm[2]);
+          cl[j] = cm[1] + cm[2] + ': ' + entry.type + cm[3] + cl[j].slice(cm[0].length);
+          movedDts.add(entry.idx);
+        }
+      }
+
+      if (movedDts.size > 0) {
+        code = cl.join('\n');
+        headerDts = dl.filter((_, i) => !movedDts.has(i)).join('\n').trimEnd() + '\n';
+      }
+    }
+  }
+
+  let tsContent = (hasTypes ? headerDts + '\n' : '') + code;
+  const headerLines = hasTypes ? countLines(headerDts + '\n') : 1;
 
   // Build bidirectional line maps
   const { srcToGen, genToSrc } = buildLineMap(result.reverseMap, result.map, headerLines);
 
+  // Snapshot code-section mappings before DTS mapping can overwrite them.
+  // Needed by @ts-expect-error injection which must target code lines, not DTS.
+  const codeSrcToGen = new Map(srcToGen);
+
   // Map DTS declaration lines back to source lines (bidirectional).
-  // Covers: let/var declarations, type aliases, interfaces, enums, classes.
+  // Covers: imports, let/var declarations, type aliases, interfaces, enums, classes.
   // This enables hover, go-to-definition, and diagnostics for type-only code.
-  if (hasTypes && dts) {
-    const dtsLines = dts.split('\n');
+  if (hasTypes && headerDts) {
+    const dtsLines = headerDts.split('\n');
     const srcLines = source.split('\n');
     for (let i = 0; i < dtsLines.length; i++) {
       const line = dtsLines[i];
+
       const m = line.match(/^(?:export\s+)?(?:declare\s+)?(?:let|var|type|interface|enum|class)\s+(\w+)/);
       if (!m) continue;
       const name = m[1];
       for (let s = 0; s < srcLines.length; s++) {
         const src = srcLines[s];
-        if (new RegExp('\\b' + name + '\\s*(?:::=|::)').test(src) ||
+        if (new RegExp('\\b' + name + '\\s*::').test(src) ||
+            new RegExp('^(?:export\\s+)?type\\s+' + name + '\\b').test(src) ||
             new RegExp('^(?:export\\s+)?interface\\s+' + name + '\\b').test(src) ||
             new RegExp('^(?:export\\s+)?enum\\s+' + name + '\\b').test(src) ||
             new RegExp('^(?:export\\s+)?' + name + '\\s*=\\s*component\\b').test(src)) {
@@ -144,6 +279,50 @@ export function compileForCheck(filePath, source, compiler) {
     }
   }
 
+  // Inject @ts-expect-error directives from Rip source into the generated
+  // TypeScript.  This lets TypeScript natively suppress expected errors and
+  // report TS2578 for unused directives — works in both CLI and LSP.
+  if (hasTypes) {
+    const srcLines = source.split('\n');
+    const injects = [];
+    for (let s = 0; s < srcLines.length; s++) {
+      const m = srcLines[s].match(/^\s*#\s*(@ts-expect-error\b.*)/);
+      if (m) {
+        const nextSrc = s + 1;
+        // Prefer code-section line (where the assignment lives and TS reports
+        // the error) over the DTS declaration line.
+        let genLine = codeSrcToGen.get(nextSrc);
+        if (genLine === undefined) {
+          genLine = srcToGen.get(nextSrc);
+          if (genLine !== undefined && genLine < headerLines) genLine = undefined;
+        }
+        if (genLine !== undefined) {
+          injects.push({ genLine, srcLine: s, comment: `// ${m[1]}` });
+        }
+      }
+    }
+    if (injects.length > 0) {
+      // Sort descending so bottom-up insertion doesn't shift earlier positions
+      injects.sort((a, b) => b.genLine - a.genLine);
+      const tsLines = tsContent.split('\n');
+      for (const { genLine, srcLine, comment } of injects) {
+        tsLines.splice(genLine, 0, comment);
+        // Shift existing gen→src mappings at or after the insertion point
+        const shifted = new Map();
+        for (const [g, s] of genToSrc) shifted.set(g >= genLine ? g + 1 : g, s);
+        shifted.set(genLine, srcLine);
+        genToSrc.clear();
+        for (const [g, s] of shifted) genToSrc.set(g, s);
+        // Shift existing src→gen mappings that pointed at or past the insertion
+        for (const [s, g] of srcToGen) {
+          if (g >= genLine) srcToGen.set(s, g + 1);
+        }
+        srcToGen.set(srcLine, genLine);
+      }
+      tsContent = tsLines.join('\n');
+    }
+  }
+
   return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, source, dts };
 }
 
@@ -288,6 +467,9 @@ export async function runCheck(targetDir, opts = {}) {
 
   const service = ts.createLanguageService(host, ts.createDocumentRegistry());
 
+  // Patch uninitialized variables with inferred types (same as LSP)
+  patchUninitializedTypes(ts, service, compiled);
+
   // Collect diagnostics
   let totalErrors = 0;
   let totalWarnings = 0;

package/src/types.js

@@ -26,7 +26,7 @@ export function installTypeSupport(Lexer) {
   //
   // Scans the token stream for:
   //   :: (TYPE_ANNOTATION) — collects type string, stores on surviving token
-  //   ::= (TYPE_ALIAS) — collects type body, replaces with TYPE_DECL marker
+  //   type Name = (contextual keyword) — collects type body, replaces with TYPE_DECL marker
   //   INTERFACE — collects body, replaces with TYPE_DECL marker
   //   DEF IDENTIFIER<...> — collects generic params via .spaced detection
   //
@@ -50,29 +50,27 @@ export function installTypeSupport(Lexer) {
     this.scanTokens((token, i, tokens) => {
       let tag = token[0];
 
-      // ── Generic type parameters: DEF name<T>(...) or Name<T> ::= ───────
+      // ── Generic type parameters: DEF name<T>(...) ──────────────────────
+      // (Generic params on type aliases are handled by the `type` keyword handler below)
       if (tag === 'IDENTIFIER') {
         let next = tokens[i + 1];
         if (next && next[0] === 'COMPARE' && next[1] === '<' && !next.spaced) {
           let isDef = tokens[i - 1]?.[0] === 'DEF';
           let genTokens = collectBalancedAngles(tokens, i + 1);
-          if (genTokens) {
-            let isAlias = !isDef && tokens[i + 1 + genTokens.length]?.[0] === 'TYPE_ALIAS';
-            if (isDef || isAlias) {
-              if (!token.data) token.data = {};
-              token.data.typeParams = buildTypeString(genTokens);
-              tokens.splice(i + 1, genTokens.length);
-              // After removing <T>, retag ( as CALL_START if it follows DEF IDENTIFIER
-              if (isDef && tokens[i + 1]?.[0] === '(') {
-                tokens[i + 1][0] = 'CALL_START';
-                // Find matching ) and retag as CALL_END
-                let d = 1, m = i + 2;
-                while (m < tokens.length && d > 0) {
-                  if (tokens[m][0] === '(' || tokens[m][0] === 'CALL_START') d++;
-                  if (tokens[m][0] === ')' || tokens[m][0] === 'CALL_END') d--;
-                  if (d === 0) tokens[m][0] = 'CALL_END';
-                  m++;
-                }
+          if (genTokens && isDef) {
+            if (!token.data) token.data = {};
+            token.data.typeParams = buildTypeString(genTokens);
+            tokens.splice(i + 1, genTokens.length);
+            // After removing <T>, retag ( as CALL_START if it follows DEF IDENTIFIER
+            if (tokens[i + 1]?.[0] === '(') {
+              tokens[i + 1][0] = 'CALL_START';
+              // Find matching ) and retag as CALL_END
+              let d = 1, m = i + 2;
+              while (m < tokens.length && d > 0) {
+                if (tokens[m][0] === '(' || tokens[m][0] === 'CALL_START') d++;
+                if (tokens[m][0] === ')' || tokens[m][0] === 'CALL_END') d--;
+                if (d === 0) tokens[m][0] = 'CALL_END';
+                m++;
               }
             }
           }
@@ -125,14 +123,33 @@ export function installTypeSupport(Lexer) {
         return 0;
       }
 
-      // ── TYPE_ALIAS (::=) — collect type body, create TYPE_DECL marker ───
-      if (tag === 'TYPE_ALIAS') {
-        let nameToken = tokens[i - 1];
-        if (!nameToken) return 1;
+      // ── type Name = ... — contextual type keyword ──────────────────────
+      if (tag === 'IDENTIFIER' && token[1] === 'type') {
+        let prevTag = tokens[i - 1]?.[0];
+        let atStatement = !prevTag || prevTag === 'TERMINATOR' || prevTag === 'INDENT' || prevTag === 'EXPORT';
+        if (!atStatement) return 1;
+
+        let nameIdx = i + 1;
+        let nameToken = tokens[nameIdx];
+        if (!nameToken || nameToken[0] !== 'IDENTIFIER') return 1;
         let name = nameToken[1];
-        let exported = i >= 2 && tokens[i - 2]?.[0] === 'EXPORT';
-        let removeFrom = exported ? i - 2 : i - 1;
-        let next = tokens[i + 1];
+
+        let exported = prevTag === 'EXPORT';
+        let removeFrom = exported ? i - 1 : i;
+
+        // Handle generic type parameters: type Name<T> = ...
+        let eqIdx = nameIdx + 1;
+        if (tokens[eqIdx]?.[0] === 'COMPARE' && tokens[eqIdx]?.[1] === '<' && !tokens[eqIdx].spaced) {
+          let genTokens = collectBalancedAngles(tokens, eqIdx);
+          if (genTokens) {
+            if (!nameToken.data) nameToken.data = {};
+            nameToken.data.typeParams = buildTypeString(genTokens);
+            tokens.splice(eqIdx, genTokens.length);
+          }
+        }
+
+        // Must have = after name (or after stripped generics)
+        if (tokens[eqIdx]?.[0] !== '=') return 1;
 
         let makeDecl = (typeText) => {
           let dt = gen('TYPE_DECL', name, nameToken);
@@ -141,26 +158,29 @@ export function installTypeSupport(Lexer) {
           return dt;
         };
 
-        // Structural type: Name ::= type INDENT ... OUTDENT
-        if (next && next[0] === 'IDENTIFIER' && next[1] === 'type' &&
-            tokens[i + 2]?.[0] === 'INDENT') {
-          let endIdx = findMatchingOutdent(tokens, i + 2);
-          tokens.splice(removeFrom, endIdx - removeFrom + 1, makeDecl(collectStructuralType(tokens, i + 2)));
-          return 0;
-        }
+        let afterEq = eqIdx + 1;
+        let next = tokens[afterEq];
 
-        // Block union: Name ::= TERMINATOR INDENT | "a" | "b" ... OUTDENT
+        // Block union: type Name = (TERMINATOR?) INDENT | "a" | "b" ... OUTDENT
+        // Must check before structural — `=` suppresses TERMINATOR so INDENT follows directly
         if (next && (next[0] === 'TERMINATOR' || next[0] === 'INDENT')) {
-          let result = collectBlockUnion(tokens, i + 1);
+          let result = collectBlockUnion(tokens, afterEq);
           if (result) {
             tokens.splice(removeFrom, result.endIdx - removeFrom + 1, makeDecl(result.typeText));
             return 0;
           }
         }
 
-        // Simple alias: Name ::= type-expression
-        let typeTokens = collectTypeExpression(tokens, i + 1);
-        tokens.splice(removeFrom, i + 1 + typeTokens.length - removeFrom, makeDecl(buildTypeString(typeTokens)));
+        // Structural type: type Name = INDENT ... OUTDENT
+        if (next && next[0] === 'INDENT') {
+          let endIdx = findMatchingOutdent(tokens, afterEq);
+          tokens.splice(removeFrom, endIdx - removeFrom + 1, makeDecl(collectStructuralType(tokens, afterEq)));
+          return 0;
+        }
+
+        // Simple alias: type Name = type-expression
+        let typeTokens = collectTypeExpression(tokens, afterEq);
+        tokens.splice(removeFrom, afterEq + typeTokens.length - removeFrom, makeDecl(buildTypeString(typeTokens)));
         return 0;
       }
 
@@ -932,9 +952,14 @@ export function emitTypes(tokens, sexpr = null) {
   let preamble = [];
   if (usesSignal) {
     preamble.push('interface Signal<T> { value: T; read(): T; lock(): Signal<T>; free(): Signal<T>; kill(): T; }');
+    preamble.push('declare function __state<T>(value: T): Signal<T>;');
   }
   if (usesComputed) {
     preamble.push('interface Computed<T> { readonly value: T; read(): T; lock(): Computed<T>; free(): Computed<T>; kill(): T; }');
+    preamble.push('declare function __computed<T>(fn: () => T): Computed<T>;');
+  }
+  if (usesSignal || usesComputed) {
+    preamble.push('declare function __effect(fn: () => void | (() => void)): () => void;');
   }
   if (preamble.length > 0) {
     preamble.push('');