rip-lang 3.13.80 → 3.13.81

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.13.80-blue.svg" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.13.81-blue.svg" alt="Version"></a>
   <a href="#zero-dependencies"><img src="https://img.shields.io/badge/dependencies-ZERO-brightgreen.svg" alt="Dependencies"></a>
   <a href="#"><img src="https://img.shields.io/badge/tests-1%2C436%2F1%2C436-brightgreen.svg" alt="Tests"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"></a>

package/bin/rip

@@ -32,7 +32,6 @@ Usage:
 Options:
   -c, --compile       Show compiled JavaScript output
   -d, --dts           Show type declarations
-  -l, --lsp           Show LSP TypeScript output (DTS + typed code for IntelliSense)
   -m, --map           Embed inline source map in compiled output
   -h, --help          Show this help message
   -o, --output <file> Write JavaScript to file
@@ -162,7 +161,6 @@ async function main() {
   const showSExpr = ripOptions.includes('-s') || ripOptions.includes('--sexpr');
   const showCompiled = ripOptions.includes('-c') || ripOptions.includes('--compile');
   const generateDts = ripOptions.includes('-d') || ripOptions.includes('--dts');
-  const showLsp = ripOptions.includes('-l') || ripOptions.includes('--lsp');
   const generateMap = ripOptions.includes('-m') || ripOptions.includes('--map');
   const quiet = ripOptions.includes('-q') || ripOptions.includes('--quiet');
 
@@ -176,7 +174,7 @@ async function main() {
   }
 
   // Stdin handling — read into memory; only write temp file for the execute path
-  const hasCompileFlag = showCompiled || showTokens || showSExpr || generateDts || showLsp || generateMap || outputFile;
+  const hasCompileFlag = showCompiled || showTokens || showSExpr || generateDts || generateMap || outputFile;
   let source;
 
   if (!inputFile) {
@@ -257,24 +255,20 @@ async function main() {
 
   try {
     const compiler = new Compiler({ showTokens, showSExpr, quiet,
-      types: (generateDts || showLsp) ? 'emit' : undefined,
+      types: generateDts ? 'emit' : undefined,
       sourceMap: generateMap ? 'inline' : undefined,
-      mode: showLsp ? 'lsp' : undefined,
     });
     const result = compiler.compile(source);
 
     if (outputFile) {
       writeFileSync(outputFile, result.code, 'utf-8');
       if (!quiet) console.log(`Compiled to ${outputFile}`);
-    } else if (showLsp) {
-      if (!quiet) console.log(`// == LSP TypeScript output by Rip ${VERSION} == //\n`);
-      console.log(result.code);
     } else if (showCompiled) {
       if (!quiet) console.log(`// == JavaScript output by Rip ${VERSION} == //\n`);
       console.log(result.code);
     }
 
-    if (generateDts && !showLsp && result.dts) {
+    if (generateDts && result.dts) {
       if (!quiet) console.log(`// == Type declarations == //\n`);
       console.log(result.dts);
     }

package/package.json

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

package/src/compiler.js

@@ -297,11 +297,6 @@ export class CodeGenerator {
       if (entry.loc) {
         this.sourceMap.addMapping(lineOffset, 0, entry.loc.r, entry.loc.c);
       }
-      if (entry.subLocs) {
-        for (const { lineOffset: lo, loc } of entry.subLocs) {
-          if (loc) this.sourceMap.addMapping(lineOffset + lo, 0, loc.r, loc.c);
-        }
-      }
       lineOffset += entry.code.split('\n').length;
     }
   }
@@ -624,12 +619,7 @@ export class CodeGenerator {
         if (!blockStmts.includes(h) || !generated.endsWith('}')) generated += ';';
       }
       let loc = Array.isArray(stmt) ? stmt.loc : null;
-      let entry = { code: generated, loc };
-      if (this._pendingComponentLineLocs) {
-        entry.subLocs = this._pendingComponentLineLocs;
-        this._pendingComponentLineLocs = null;
-      }
-      return entry;
+      return { code: generated, loc };
     });
     let statementsCode = stmtEntries.map(e => e.code).join('\n');
 
@@ -681,32 +671,26 @@ export class CodeGenerator {
       }
     }
 
-    if (this.options.lspMode && (this.usesReactivity || this.usesTemplates)) {
-      if (needsBlank) code += '\n';
-      code += getLspRuntimeDeclarations();
-      needsBlank = true;
-    } else {
-      if (this.usesReactivity && !skip) {
-        if (skipRT) {
-          code += 'var { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
-        } else if (typeof globalThis !== 'undefined' && globalThis.__rip) {
-          code += 'const { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
-        } else {
-          code += this.getReactiveRuntime();
-        }
-        needsBlank = true;
+    if (this.usesReactivity && !skip) {
+      if (skipRT) {
+        code += 'var { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
+      } else if (typeof globalThis !== 'undefined' && globalThis.__rip) {
+        code += 'const { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors } = globalThis.__rip;\n';
+      } else {
+        code += this.getReactiveRuntime();
       }
+      needsBlank = true;
+    }
 
-      if (this.usesTemplates && !skip) {
-        if (skipRT) {
-          code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
-        } else if (typeof globalThis !== 'undefined' && globalThis.__ripComponent) {
-          code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
-        } else {
-          code += this.getComponentRuntime();
-        }
-        needsBlank = true;
+    if (this.usesTemplates && !skip) {
+      if (skipRT) {
+        code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+      } else if (typeof globalThis !== 'undefined' && globalThis.__ripComponent) {
+        code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+      } else {
+        code += this.getComponentRuntime();
       }
+      needsBlank = true;
     }
 
     if (this.dataSection !== null && this.dataSection !== undefined && !skip) {
@@ -3305,15 +3289,13 @@ export class Compiler {
       sourceMap = new SourceMapGenerator(file, sourceFile, source);
     }
 
-    let lspMode = this.options.mode === 'lsp';
-
     let generator = new CodeGenerator({
       dataSection,
-      skipPreamble: lspMode || this.options.skipPreamble,
+      skipPreamble: this.options.skipPreamble,
       skipRuntimes: this.options.skipRuntimes,
       skipExports: this.options.skipExports,
+      stubComponents: this.options.stubComponents,
       reactiveVars: this.options.reactiveVars,
-      lspMode,
       sourceMap,
     });
     let code = generator.compile(sexpr);
@@ -3332,11 +3314,6 @@ export class Compiler {
       dts = emitTypes(typeTokens, sexpr);
     }
 
-    // LSP mode: prepend DTS to code for a single combined output
-    if (lspMode && dts) {
-      code = dts.trimEnd() + '\n\n' + code;
-    }
-
     return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
   }
 
@@ -3398,24 +3375,4 @@ export function getComponentRuntime() {
   return new CodeGenerator({}).getComponentRuntime();
 }
 
-export function getLspRuntimeDeclarations() {
-  return `\
-interface Signal<T> { value: T; read(): T; }
-interface Computed<T> { readonly value: T; read(): T; }
-declare function __state<T>(v: T): Signal<T>;
-declare function __computed<T>(fn: () => T): Computed<T>;
-declare function __effect(fn: () => void | (() => void)): () => void;
-declare function __batch<T>(fn: () => T): T;
-declare function __readonly<T>(v: T): Readonly<{ value: T }>;
-declare function __pushComponent(component: any): any;
-declare function __popComponent(prev: any): void;
-declare function __handleComponentError(error: any, component: any): void;
-declare function __clsx(...args: any[]): string;
-declare function setContext(key: string, value: any): void;
-declare function getContext(key: string): any;
-declare function hasContext(key: string): boolean;
-declare class __Component { constructor(props?: any); _create?(): any; _setup?(): void; _root?: any; _children?: any[]; [key: string]: any; }
-`;
-}
-
 export { formatSExpr };

package/src/components.js

@@ -669,6 +669,8 @@ export function installComponentSupport(CodeGenerator, Lexer) {
    * Pattern: ["component", null, ["block", ...statements]]
    */
   proto.generateComponent = function(head, rest, context, sexpr) {
+    if (this.options.stubComponents) return 'class {}';
+
     const [, body] = rest;
 
     this.usesTemplates = true;
@@ -713,35 +715,35 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       } else if (op === 'state') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          stateVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]), loc: stmt.loc });
+          stateVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]) });
           memberNames.add(varName);
           reactiveMembers.add(varName);
         }
       } else if (op === 'computed') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          derivedVars.push({ name: varName, expr: stmt[2], loc: stmt.loc });
+          derivedVars.push({ name: varName, expr: stmt[2] });
           memberNames.add(varName);
           reactiveMembers.add(varName);
         }
       } else if (op === 'readonly') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          readonlyVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]), loc: stmt.loc });
+          readonlyVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]) });
           memberNames.add(varName);
         }
       } else if (op === '=') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
           if (LIFECYCLE_HOOKS.has(varName)) {
-            lifecycleHooks.push({ name: varName, value: stmt[2], loc: stmt.loc });
+            lifecycleHooks.push({ name: varName, value: stmt[2] });
           } else {
             const val = stmt[2];
             if (Array.isArray(val) && (val[0] === '->' || val[0] === '=>')) {
-              methods.push({ name: varName, func: val, loc: stmt.loc });
+              methods.push({ name: varName, func: val });
               memberNames.add(varName);
             } else {
-              stateVars.push({ name: varName, value: val, isPublic: isPublicProp(stmt[1]), loc: stmt.loc });
+              stateVars.push({ name: varName, value: val, isPublic: isPublicProp(stmt[1]) });
               memberNames.add(varName);
               reactiveMembers.add(varName);
             }
@@ -757,9 +759,9 @@ export function installComponentSupport(CodeGenerator, Lexer) {
           if (!Array.isArray(pair)) continue;
           const [methodName, funcDef] = pair;
           if (typeof methodName === 'string' && LIFECYCLE_HOOKS.has(methodName)) {
-            lifecycleHooks.push({ name: methodName, value: funcDef, loc: pair.loc });
+            lifecycleHooks.push({ name: methodName, value: funcDef });
           } else if (typeof methodName === 'string') {
-            methods.push({ name: methodName, func: funcDef, loc: pair.loc });
+            methods.push({ name: methodName, func: funcDef });
             memberNames.add(methodName);
           }
         }
@@ -783,76 +785,49 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     this._autoEventHandlers = autoEventHandlers.size > 0 ? autoEventHandlers : null;
 
     const lines = [];
-    const lineLocs = [];
     let blockFactoriesCode = '';
 
-    let totalLines = 0;
-    const pushLine = (line, loc) => {
-      if (loc) lineLocs.push({ lineOffset: totalLines, loc });
-      lines.push(line);
-      totalLines += line.split('\n').length;
-    };
-    const pushPlain = (line) => {
-      lines.push(line);
-      totalLines += line.split('\n').length;
-    };
-
-    pushPlain('class extends __Component {');
+    lines.push('class extends __Component {');
 
     // --- Init (called by __Component constructor) ---
-    if (this.options.lspMode) {
-      const typedProps = [];
-      for (const v of [...readonlyVars, ...stateVars]) {
-        if (v.isPublic) {
-          const t = v.type || 'any';
-          typedProps.push(`${v.name}?: ${t}`);
-          typedProps.push(`__bind_${v.name}__?: ${t}`);
-        }
-      }
-      const propsType = typedProps.length > 0
-        ? `{ ${typedProps.join(', ')}, [key: string]: any }`
-        : 'any';
-      pushPlain(`  _init(props: ${propsType}) {`);
-    } else {
-      pushPlain('  _init(props) {');
-    }
+    lines.push('  _init(props) {');
 
     // Constants (readonly)
-    for (const { name, value, isPublic, loc } of readonlyVars) {
+    for (const { name, value, isPublic } of readonlyVars) {
       const val = this.generateInComponent(value, 'value');
-      pushLine(isPublic
+      lines.push(isPublic
         ? `    this.${name} = props.${name} ?? ${val};`
-        : `    this.${name} = ${val};`, loc);
+        : `    this.${name} = ${val};`);
     }
 
     // Accepted vars (from ancestor context via getContext)
     for (const name of acceptedVars) {
-      pushPlain(`    this.${name} = getContext('${name}');`);
+      lines.push(`    this.${name} = getContext('${name}');`);
     }
 
     // State variables (__state handles signal passthrough)
-    for (const { name, value, isPublic, loc } of stateVars) {
+    for (const { name, value, isPublic } of stateVars) {
       const val = this.generateInComponent(value, 'value');
-      pushLine(isPublic
+      lines.push(isPublic
         ? `    this.${name} = __state(props.__bind_${name}__ ?? props.${name} ?? ${val});`
-        : `    this.${name} = __state(${val});`, loc);
+        : `    this.${name} = __state(${val});`);
     }
 
     // Computed (derived)
-    for (const { name, expr, loc } of derivedVars) {
+    for (const { name, expr } of derivedVars) {
       if (this.is(expr, 'block')) {
         const transformed = this.transformComponentMembers(expr);
         const body = this.generateFunctionBody(transformed);
-        pushLine(`    this.${name} = __computed(() => ${body});`, loc);
+        lines.push(`    this.${name} = __computed(() => ${body});`);
       } else {
         const val = this.generateInComponent(expr, 'value');
-        pushLine(`    this.${name} = __computed(() => ${val});`, loc);
+        lines.push(`    this.${name} = __computed(() => ${val});`);
       }
     }
 
     // Offered vars (share with descendants via setContext — after all members are initialized)
     for (const name of offeredVars) {
-      pushPlain(`    setContext('${name}', this.${name});`);
+      lines.push(`    setContext('${name}', this.${name});`);
     }
 
     // Effects
@@ -862,36 +837,36 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       if (this.is(effectBody, 'block')) {
         const transformed = this.transformComponentMembers(effectBody);
         const body = this.generateFunctionBody(transformed, [], true);
-        pushLine(`    __effect(${isAsync}() => ${body});`, effect.loc);
+        lines.push(`    __effect(${isAsync}() => ${body});`);
       } else {
         const effectCode = this.generateInComponent(effectBody, 'value');
-        pushLine(`    __effect(${isAsync}() => { ${effectCode}; });`, effect.loc);
+        lines.push(`    __effect(${isAsync}() => { ${effectCode}; });`);
       }
     }
 
-    pushPlain('  }');
+    lines.push('  }');
 
     // --- Methods ---
-    for (const { name, func, loc } of methods) {
+    for (const { name, func } of methods) {
       if (Array.isArray(func) && (func[0] === '->' || func[0] === '=>')) {
         const [, params, methodBody] = func;
         const paramStr = Array.isArray(params) ? params.map(p => this.formatParam(p)).join(', ') : '';
         const transformed = this.reactiveMembers ? this.transformComponentMembers(methodBody) : methodBody;
         const isAsync = this.containsAwait(methodBody);
         const bodyCode = this.generateFunctionBody(transformed, params || []);
-        pushLine(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`, loc);
+        lines.push(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`);
       }
     }
 
     // --- Lifecycle hooks ---
-    for (const { name, value, loc } of lifecycleHooks) {
+    for (const { name, value } of lifecycleHooks) {
       if (Array.isArray(value) && (value[0] === '->' || value[0] === '=>')) {
         const [, params, hookBody] = value;
         const paramStr = Array.isArray(params) ? params.map(p => this.formatParam(p)).join(', ') : '';
         const transformed = this.reactiveMembers ? this.transformComponentMembers(hookBody) : hookBody;
         const isAsync = this.containsAwait(hookBody);
         const bodyCode = this.generateFunctionBody(transformed, params || []);
-        pushLine(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`, loc);
+        lines.push(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`);
       }
     }
 
@@ -900,43 +875,35 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       const renderBody = renderBlock[1];
       const result = this.buildRender(renderBody);
 
-      if (!this.options.lspMode && result.blockFactories.length > 0) {
+      if (result.blockFactories.length > 0) {
         blockFactoriesCode = result.blockFactories.join('\n\n') + '\n\n';
       }
 
-      pushLine('  _create() {', renderBlock.loc);
+      lines.push('  _create() {');
       for (const line of result.createLines) {
-        pushPlain(`    ${line}`);
+        lines.push(`    ${line}`);
       }
-      pushPlain(`    return ${result.rootVar};`);
-      pushPlain('  }');
+      lines.push(`    return ${result.rootVar};`);
+      lines.push('  }');
 
-      if (!this.options.lspMode && result.setupLines.length > 0) {
-        pushPlain('  _setup() {');
+      if (result.setupLines.length > 0) {
+        lines.push('  _setup() {');
         for (const line of result.setupLines) {
-          pushPlain(`    ${line}`);
+          lines.push(`    ${line}`);
         }
-        pushPlain('  }');
+        lines.push('  }');
       }
     }
 
-    pushPlain('}');
+    lines.push('}');
 
     // Restore context
     this.componentMembers = prevComponentMembers;
     this.reactiveMembers = prevReactiveMembers;
     this._autoEventHandlers = prevAutoEventHandlers;
 
-    // Store line-level source mappings for the parent statement entry
-    if (lineLocs.length > 0) {
-      this._pendingComponentLineLocs = lineLocs;
-    }
-
     // If block factories exist, wrap in IIFE so they're in scope
     if (blockFactoriesCode) {
-      // Adjust lineOffsets for the IIFE wrapper + block factories prefix
-      const prefixLines = blockFactoriesCode.split('\n').length;
-      for (const entry of lineLocs) entry.lineOffset += prefixLines;
       return `(() => {\n${blockFactoriesCode}return ${lines.join('\n')};\n})()`;
     }
 

package/src/typecheck.js

@@ -41,11 +41,12 @@ export const SKIP_CODES = new Set([
   2307, // Cannot find module
   2393, // Duplicate function implementation
   2451, // Cannot redeclare block-scoped variable
-  2554, // Expected N arguments but got M (generated event handler wrappers pass event arg)
-  7006, // Parameter implicitly has 'any' type (generated event callback params)
   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)
+  7005, // Variable implicitly has an 'any' type (compiler-generated locals)
+  7006, // Parameter implicitly has an 'any' type (compiler-generated params)
+  7034, // Variable implicitly has type 'any' in some locations (compiler-generated)
 ]);
 
 // Base TypeScript compiler settings for type-checking. Callers can
@@ -66,12 +67,13 @@ export function createTypeCheckSettings(ts, overrides = {}) {
 
 // ── Shared compilation pipeline ────────────────────────────────────
 
-// Compile a .rip file for type-checking. Uses mode: 'lsp' which emits
-// DTS + typed runtime declarations + compiled code in a single output.
-// Builds bidirectional source maps for the LSP and CLI checker.
+// Compile a .rip file for type-checking. Prepends DTS declarations to
+// compiled JS, detects type annotations, and builds bidirectional
+// source maps. Returns everything both the CLI and LSP need.
 export function compileForCheck(filePath, source, compiler) {
-  const result = compiler.compile(source, { sourceMap: true, types: 'emit', mode: 'lsp' });
+  const result = compiler.compile(source, { sourceMap: true, types: 'emit', skipPreamble: true, stubComponents: true });
   let code = result.code || '';
+  const dts = result.dts ? result.dts.trimEnd() + '\n' : '';
 
   // Determine if this file should be type-checked
   const hasOwnTypes = hasTypeAnnotations(source);
@@ -92,9 +94,8 @@ 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 dts = result.dts ? result.dts.trimEnd() + '\n' : '';
-  const tsContent = code;
-  const headerLines = hasTypes && dts ? countLines(dts + '\n') : 1;
+  const tsContent = (hasTypes ? dts + '\n' : '') + code;
+  const headerLines = hasTypes ? countLines(dts + '\n') : 1;
 
   // Build bidirectional line maps
   const { srcToGen, genToSrc } = buildLineMap(result.reverseMap, result.map, headerLines);
@@ -143,7 +144,7 @@ export function compileForCheck(filePath, source, compiler) {
     }
   }
 
-  return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, source };
+  return { tsContent, headerLines, hasTypes, srcToGen, genToSrc, source, dts };
 }
 
 // ── Source mapping helpers ──────────────────────────────────────────
@@ -246,7 +247,7 @@ export async function runCheck(targetDir, opts = {}) {
   }
 
   // Create TypeScript language service
-  const settings = createTypeCheckSettings(ts, { noImplicitAny: true });
+  const settings = createTypeCheckSettings(ts);
 
   const host = {
     getScriptFileNames: () => [...compiled.keys()].map(toVirtual),