rip-lang 3.13.78 → 3.13.80

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.78-blue.svg" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.13.80-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.13.78",
+  "version": "3.13.80",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",
@@ -66,5 +66,8 @@
   },
   "homepage": "https://github.com/shreeve/rip-lang#readme",
   "author": "Steve Shreeve <steve.shreeve@gmail.com>",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "5.9.3"
+  }
 }

package/src/compiler.js

@@ -297,6 +297,11 @@ 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;
     }
   }
@@ -619,7 +624,12 @@ export class CodeGenerator {
         if (!blockStmts.includes(h) || !generated.endsWith('}')) generated += ';';
       }
       let loc = Array.isArray(stmt) ? stmt.loc : null;
-      return { code: generated, loc };
+      let entry = { code: generated, loc };
+      if (this._pendingComponentLineLocs) {
+        entry.subLocs = this._pendingComponentLineLocs;
+        this._pendingComponentLineLocs = null;
+      }
+      return entry;
     });
     let statementsCode = stmtEntries.map(e => e.code).join('\n');
 
@@ -3397,10 +3407,14 @@ 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); [key: string]: any; }
+declare class __Component { constructor(props?: any); _create?(): any; _setup?(): void; _root?: any; _children?: any[]; [key: string]: any; }
 `;
 }
 

package/src/components.js

@@ -107,6 +107,16 @@ function isPublicProp(target) {
   return Array.isArray(target) && target[0] === '.' && target[1] === 'this';
 }
 
+/**
+ * Extract type annotation from s-expression target node.
+ * Type annotations are stored as .type on String objects by the type rewriter.
+ */
+function getMemberType(target) {
+  if (target instanceof String && target.type) return target.type;
+  if (Array.isArray(target) && target[2] instanceof String && target[2].type) return target[2].type;
+  return null;
+}
+
 // ============================================================================
 // Prototype Installation
 // ============================================================================
@@ -703,35 +713,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]) });
+          stateVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]), loc: stmt.loc });
           memberNames.add(varName);
           reactiveMembers.add(varName);
         }
       } else if (op === 'computed') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          derivedVars.push({ name: varName, expr: stmt[2] });
+          derivedVars.push({ name: varName, expr: stmt[2], loc: stmt.loc });
           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]) });
+          readonlyVars.push({ name: varName, value: stmt[2], isPublic: isPublicProp(stmt[1]), type: getMemberType(stmt[1]), loc: stmt.loc });
           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] });
+            lifecycleHooks.push({ name: varName, value: stmt[2], loc: stmt.loc });
           } else {
             const val = stmt[2];
             if (Array.isArray(val) && (val[0] === '->' || val[0] === '=>')) {
-              methods.push({ name: varName, func: val });
+              methods.push({ name: varName, func: val, loc: stmt.loc });
               memberNames.add(varName);
             } else {
-              stateVars.push({ name: varName, value: val, isPublic: isPublicProp(stmt[1]) });
+              stateVars.push({ name: varName, value: val, isPublic: isPublicProp(stmt[1]), loc: stmt.loc });
               memberNames.add(varName);
               reactiveMembers.add(varName);
             }
@@ -747,9 +757,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 });
+            lifecycleHooks.push({ name: methodName, value: funcDef, loc: pair.loc });
           } else if (typeof methodName === 'string') {
-            methods.push({ name: methodName, func: funcDef });
+            methods.push({ name: methodName, func: funcDef, loc: pair.loc });
             memberNames.add(methodName);
           }
         }
@@ -773,49 +783,76 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     this._autoEventHandlers = autoEventHandlers.size > 0 ? autoEventHandlers : null;
 
     const lines = [];
+    const lineLocs = [];
     let blockFactoriesCode = '';
 
-    lines.push('class extends __Component {');
+    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 {');
 
     // --- Init (called by __Component constructor) ---
-    lines.push('  _init(props) {');
+    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) {');
+    }
 
     // Constants (readonly)
-    for (const { name, value, isPublic } of readonlyVars) {
+    for (const { name, value, isPublic, loc } of readonlyVars) {
       const val = this.generateInComponent(value, 'value');
-      lines.push(isPublic
+      pushLine(isPublic
         ? `    this.${name} = props.${name} ?? ${val};`
-        : `    this.${name} = ${val};`);
+        : `    this.${name} = ${val};`, loc);
     }
 
     // Accepted vars (from ancestor context via getContext)
     for (const name of acceptedVars) {
-      lines.push(`    this.${name} = getContext('${name}');`);
+      pushPlain(`    this.${name} = getContext('${name}');`);
     }
 
     // State variables (__state handles signal passthrough)
-    for (const { name, value, isPublic } of stateVars) {
+    for (const { name, value, isPublic, loc } of stateVars) {
       const val = this.generateInComponent(value, 'value');
-      lines.push(isPublic
+      pushLine(isPublic
         ? `    this.${name} = __state(props.__bind_${name}__ ?? props.${name} ?? ${val});`
-        : `    this.${name} = __state(${val});`);
+        : `    this.${name} = __state(${val});`, loc);
     }
 
     // Computed (derived)
-    for (const { name, expr } of derivedVars) {
+    for (const { name, expr, loc } of derivedVars) {
       if (this.is(expr, 'block')) {
         const transformed = this.transformComponentMembers(expr);
         const body = this.generateFunctionBody(transformed);
-        lines.push(`    this.${name} = __computed(() => ${body});`);
+        pushLine(`    this.${name} = __computed(() => ${body});`, loc);
       } else {
         const val = this.generateInComponent(expr, 'value');
-        lines.push(`    this.${name} = __computed(() => ${val});`);
+        pushLine(`    this.${name} = __computed(() => ${val});`, loc);
       }
     }
 
     // Offered vars (share with descendants via setContext — after all members are initialized)
     for (const name of offeredVars) {
-      lines.push(`    setContext('${name}', this.${name});`);
+      pushPlain(`    setContext('${name}', this.${name});`);
     }
 
     // Effects
@@ -825,73 +862,81 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       if (this.is(effectBody, 'block')) {
         const transformed = this.transformComponentMembers(effectBody);
         const body = this.generateFunctionBody(transformed, [], true);
-        lines.push(`    __effect(${isAsync}() => ${body});`);
+        pushLine(`    __effect(${isAsync}() => ${body});`, effect.loc);
       } else {
         const effectCode = this.generateInComponent(effectBody, 'value');
-        lines.push(`    __effect(${isAsync}() => { ${effectCode}; });`);
+        pushLine(`    __effect(${isAsync}() => { ${effectCode}; });`, effect.loc);
       }
     }
 
-    lines.push('  }');
+    pushPlain('  }');
 
     // --- Methods ---
-    for (const { name, func } of methods) {
+    for (const { name, func, loc } 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 || []);
-        lines.push(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`);
+        pushLine(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`, loc);
       }
     }
 
     // --- Lifecycle hooks ---
-    for (const { name, value } of lifecycleHooks) {
+    for (const { name, value, loc } 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 || []);
-        lines.push(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`);
+        pushLine(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`, loc);
       }
     }
 
     // --- Render block (fine-grained) ---
-    if (renderBlock && !this.options.lspMode) {
+    if (renderBlock) {
       const renderBody = renderBlock[1];
       const result = this.buildRender(renderBody);
 
-      if (result.blockFactories.length > 0) {
+      if (!this.options.lspMode && result.blockFactories.length > 0) {
         blockFactoriesCode = result.blockFactories.join('\n\n') + '\n\n';
       }
 
-      lines.push('  _create() {');
+      pushLine('  _create() {', renderBlock.loc);
       for (const line of result.createLines) {
-        lines.push(`    ${line}`);
+        pushPlain(`    ${line}`);
       }
-      lines.push(`    return ${result.rootVar};`);
-      lines.push('  }');
+      pushPlain(`    return ${result.rootVar};`);
+      pushPlain('  }');
 
-      if (result.setupLines.length > 0) {
-        lines.push('  _setup() {');
+      if (!this.options.lspMode && result.setupLines.length > 0) {
+        pushPlain('  _setup() {');
         for (const line of result.setupLines) {
-          lines.push(`    ${line}`);
+          pushPlain(`    ${line}`);
         }
-        lines.push('  }');
+        pushPlain('  }');
       }
     }
 
-    lines.push('}');
+    pushPlain('}');
 
     // 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,6 +41,8 @@ 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)