rip-lang 3.10.11 → 3.10.14

package/package.json

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

package/src/compiler.js

@@ -277,56 +277,23 @@ export class CodeGenerator {
     this.collectProgramVariables(sexpr);
     let code = this.generate(sexpr);
 
-    // Build source map mappings from generated code + S-expression locations
-    if (this.sourceMap) this.buildMappings(code, sexpr);
+    // Build source map mappings from generation-time recorded entries
+    if (this.sourceMap) this.buildMappings();
 
     return code;
   }
 
-  // Build source map by walking generated output lines and S-expression nodes.
-  // Collects locations from STATEMENT-level nodes only (direct children of
-  // program/block containers), then matches them to output lines in order.
-  buildMappings(code, sexpr) {
-    if (!sexpr || sexpr[0] !== 'program') return;
-
-    // Collect statement locations: only direct children of program/block nodes.
-    // This gives exactly one loc per output statement line, in source order.
-    let locs = [];
-    let collect = (node) => {
-      if (!Array.isArray(node)) return;
-      let head = node[0];
-      if (head === 'program' || head === 'block') {
-        for (let i = 1; i < node.length; i++) {
-          let child = node[i];
-          if (Array.isArray(child) && child.loc) locs.push(child.loc);
-          collect(child);
-        }
-      } else {
-        for (let i = 1; i < node.length; i++) collect(node[i]);
-      }
-    };
-    collect(sexpr);
-
-    // Match output lines to collected statement locations in parallel.
-    // Skip lines with no source correspondence (preamble, braces, etc.).
-    let lines = code.split('\n');
-    let locIdx = 0;
-    for (let outLine = 0; outLine < lines.length; outLine++) {
-      let line = lines[outLine];
-      let trimmed = line.trim();
-
-      if (!trimmed || trimmed === '}' || trimmed === '});') continue;
-      if (trimmed.startsWith('let ') || trimmed.startsWith('var ')) continue;
-      if (trimmed.startsWith('const slice') || trimmed.startsWith('const modulo') || trimmed.startsWith('const toMatchable')) continue;
-      if (trimmed.startsWith('const {') && trimmed.includes('__')) continue;
-      if (trimmed.startsWith('} else')) continue;
-      if (trimmed.startsWith('//# source')) continue;
-
-      if (locIdx < locs.length) {
-        let indent = line.length - trimmed.length;
-        this.sourceMap.addMapping(outLine, indent, locs[locIdx].r, locs[locIdx].c);
-        locIdx++;
+  // Build source map from generation-time recorded entries.
+  // Each entry pairs a statement's generated code with its source loc.
+  // Output line positions are computed by exact arithmetic — no heuristics.
+  buildMappings() {
+    if (!this._stmtEntries) return;
+    let lineOffset = this._preambleLines;
+    for (let entry of this._stmtEntries) {
+      if (entry.loc) {
+        this.sourceMap.addMapping(lineOffset, 0, entry.loc.r, entry.loc.c);
       }
+      lineOffset += entry.code.split('\n').length;
     }
   }
 
@@ -629,7 +596,7 @@ export class CodeGenerator {
 
     // Generate body first to detect needed helpers
     let blockStmts = ['def', 'class', 'if', 'for-in', 'for-of', 'for-as', 'while', 'loop', 'switch', 'try'];
-    let statementsCode = other.map((stmt, index) => {
+    let stmtEntries = other.map((stmt, index) => {
       let isSingle = other.length === 1 && imports.length === 0 && exports.length === 0;
       let isObj = this.is(stmt, 'object');
       let isObjComp = isObj && stmt.length === 2 && Array.isArray(stmt[1]) && Array.isArray(stmt[1][1]) && stmt[1][1][0] === 'comprehension';
@@ -646,10 +613,12 @@ export class CodeGenerator {
 
       if (generated && !generated.endsWith(';')) {
         let h = Array.isArray(stmt) ? stmt[0] : null;
-        if (!blockStmts.includes(h) || !generated.endsWith('}')) return generated + ';';
+        if (!blockStmts.includes(h) || !generated.endsWith('}')) generated += ';';
       }
-      return generated;
-    }).join('\n');
+      let loc = Array.isArray(stmt) ? stmt.loc : null;
+      return { code: generated, loc };
+    });
+    let statementsCode = stmtEntries.map(e => e.code).join('\n');
 
     let needsBlank = false;
 
@@ -719,6 +688,8 @@ export class CodeGenerator {
     }
 
     if (needsBlank && code.length > 0) code += '\n';
+    this._stmtEntries = stmtEntries;
+    this._preambleLines = code.length === 0 ? 0 : code.split('\n').length - 1;
     code += statementsCode;
     code += exportsCode;
 
@@ -926,9 +897,7 @@ export class CodeGenerator {
       let mapped = this._atParamMap.get(str(prop));
       if (mapped) return mapped;
     }
-    this.suppressReactiveUnwrap = true;
     let objCode = this.generate(obj, 'value');
-    this.suppressReactiveUnwrap = false;
     let needsParens = CodeGenerator.NUMBER_LITERAL_RE.test(objCode) ||
                       objCode.startsWith('await ') ||
                       ((this.is(obj, 'object') || this.is(obj, 'yield')));

package/src/components.js

@@ -688,8 +688,14 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     // Effects
     for (const effect of effects) {
       const effectBody = effect[2];
-      const effectCode = this.generateInComponent(effectBody, 'value');
-      lines.push(`    __effect(() => { ${effectCode}; });`);
+      if (this.is(effectBody, 'block') && effectBody.length > 2) {
+        const transformed = this.transformComponentMembers(effectBody);
+        const body = this.generateFunctionBody(transformed, [], true);
+        lines.push(`    __effect(() => ${body});`);
+      } else {
+        const effectCode = this.generateInComponent(effectBody, 'value');
+        lines.push(`    __effect(() => { ${effectCode}; });`);
+      }
     }
 
     lines.push('  }');

package/src/typecheck.js

@@ -65,7 +65,7 @@ export function createTypeCheckSettings(ts, overrides = {}) {
 // the 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: true });
+  const result = compiler.compile(source, { sourceMap: true, types: true, skipPreamble: true });
   let code = result.code || '';
   let dts = result.dts ? result.dts.trimEnd() + '\n' : '';
 
@@ -107,6 +107,43 @@ export function compileForCheck(filePath, source, compiler) {
     });
   }
 
+  // Extract reactive const declarations (state, computed, readonly, effect)
+  // from DTS and merge their types into the code — same pattern as functions.
+  // DTS: `declare const clicks: Signal<number>;`  →  removed
+  // Code: `const clicks = __state(0);`  →  `const clicks: Signal<number> = __state(0);`
+  const reactiveConsts = new Map();
+  dts = dts.replace(
+    /^(?:export\s+)?(?:declare\s+)?const\s+(\w+)\s*:\s*(.+?);\s*$/gm,
+    (_m, name, type) => { reactiveConsts.set(name, type); return ''; },
+  );
+  dts = dts.replace(/^\s*\n/gm, '');
+
+  for (const [name, type] of reactiveConsts) {
+    code = code.replace(
+      new RegExp(`(const\\s+${name})\\s*=`),
+      (_, prefix) => `${prefix}: ${type} =`,
+    );
+  }
+
+  // Remove component class implementations when the DTS already has
+  // typed class declarations — avoids "Duplicate identifier" conflicts.
+  for (const m of dts.matchAll(/^(?:export\s+)?declare\s+class\s+(\w+)\b/gm)) {
+    const name = m[1];
+    const re = new RegExp(`^export\\s+const\\s+${name}\\s*=\\s*class\\s+extends\\s+\\w+`);
+    const lines = code.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (!re.test(lines[i])) continue;
+      let depth = 0, start = i;
+      for (; i < lines.length; i++) {
+        for (const ch of lines[i]) { if (ch === '{') depth++; else if (ch === '}') depth--; }
+        if (depth <= 0) break;
+      }
+      lines.splice(start, i - start + 1);
+      break;
+    }
+    code = lines.join('\n');
+  }
+
   // Remove bare `let x;` declarations when the DTS already declares
   // `let x: Type;` — avoids "Cannot redeclare" conflicts. Handles
   // both single (`let x;`) and comma-separated (`let x, y;`) forms.

package/src/types.js

@@ -1002,55 +1002,47 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars) {
     let members = (Array.isArray(body) && (body[0]?.valueOf?.() ?? body[0]) === 'block')
       ? body.slice(1) : (body ? [body] : []);
 
-    let props = [];
-    let methods = [];
+    let publicProps = [];
+    let hasRequired = false;
 
     for (let member of members) {
       if (!Array.isArray(member)) continue;
       let mHead = member[0]?.valueOf?.() ?? member[0];
 
-      // Reactive state: ["state", "count", 0]
-      if (mHead === 'state') {
-        let propName = member[1]?.valueOf?.() ?? member[1];
-        let type = member[1]?.type;
-        props.push(`  ${propName}: ${type ? expandSuffixes(type) : 'any'};`);
-        componentVars.add(propName);
-      }
-      // Computed: ["computed", "doubled", expr]
-      else if (mHead === 'computed') {
-        let propName = member[1]?.valueOf?.() ?? member[1];
-        let type = member[1]?.type;
-        props.push(`  readonly ${propName}: ${type ? expandSuffixes(type) : 'any'};`);
+      let target, propName, isProp, type, hasDefault;
+
+      if (mHead === 'state' || mHead === 'readonly' || mHead === 'computed') {
+        target = member[1];
+        isProp = Array.isArray(target) && (target[0]?.valueOf?.() ?? target[0]) === '.' && (target[1]?.valueOf?.() ?? target[1]) === 'this';
+        propName = isProp ? (target[2]?.valueOf?.() ?? target[2]) : (target?.valueOf?.() ?? target);
+        type = isProp ? target[2]?.type : target?.type;
+        hasDefault = true;
         componentVars.add(propName);
-      }
-      // Method object: ["object", ["methodName", ["->", params, body], ":"]]
-      else if (mHead === 'object') {
-        for (let j = 1; j < member.length; j++) {
-          let entry = member[j];
-          if (!Array.isArray(entry)) continue;
-          let methodName = entry[0]?.valueOf?.() ?? entry[0];
-          if (methodName === 'render') continue; // skip render
-          let fn = entry[1];
-          if (Array.isArray(fn)) {
-            let fnHead = fn[0]?.valueOf?.() ?? fn[0];
-            if (fnHead === '->' || fnHead === '=>') {
-              methods.push(`  ${methodName}(): void;`);
-            }
-          }
-        }
-      }
-      // Skip render blocks
-      else if (mHead === 'render') {
+      } else if (mHead === '.') {
+        isProp = (member[1]?.valueOf?.() ?? member[1]) === 'this';
+        propName = isProp ? (member[2]?.valueOf?.() ?? member[2]) : null;
+        type = isProp ? member[2]?.type : null;
+        hasDefault = false;
+        if (propName) componentVars.add(propName);
+      } else {
         continue;
       }
+
+      if (!isProp || !propName) continue;
+
+      let typeStr = type ? expandSuffixes(type) : 'any';
+      let opt = hasDefault ? '?' : '';
+      if (!hasDefault) hasRequired = true;
+      publicProps.push(`    ${propName}${opt}: ${typeStr};`);
     }
 
     lines.push(`${exp}declare class ${name} {`);
-    lines.push(`  constructor(props?: Record<string, any>);`);
-    for (let p of props) lines.push(p);
-    for (let m of methods) lines.push(m);
-    lines.push(`  mount(target: Element | string): ${name};`);
-    lines.push(`  unmount(): void;`);
+    if (publicProps.length > 0) {
+      let propsOpt = hasRequired ? '' : '?';
+      lines.push(`  constructor(props${propsOpt}: {`);
+      for (let p of publicProps) lines.push(p);
+      lines.push(`  });`);
+    }
     lines.push(`}`);
   }