future-lang 0.4.0 → 0.4.2

package/src/cli.js

@@ -11,7 +11,7 @@
 //   future help | --help
 //   future version | --version
 
-import { readFileSync, writeFileSync, unlinkSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, dirname, extname, join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { tmpdir } from 'node:os';
@@ -20,8 +20,9 @@ import process from 'node:process';
 import { compile, tokenize, parse } from './index.js';
 import { format } from './formatter.js';
 import { FutureError } from './errors.js';
+import { buildSourceMap } from './sourcemap.js';
 
-const VERSION = '0.4.0';
+const VERSION = '0.4.2';
 const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const RUNTIME_INDEX = join(PROJECT_ROOT, 'runtime', 'index.js');
 
@@ -30,13 +31,15 @@ const USAGE = `Future ${VERSION} — a tiny language that compiles to JavaScript
 Usage:
   future run <file.future>          Compile and run a program
   future compile <file.future>      Compile to JavaScript (<file>.js)
-  future new <name>                  Create a new project
+  future test [pattern]             Run *.test.future files
+  future ast <file.future>          Print the AST as JSON
+  future new <name>                 Create a new project
   future check <file.future>        Check for syntax errors
   future fmt <file.future>          Format source code in-place
-  future playground                  Launch the interactive playground
-  future doctor                      Check your environment
-  future help                        Show this help
-  future --version                   Show the version
+  future playground                 Launch the interactive playground
+  future doctor                     Check your environment
+  future help                       Show this help
+  future --version                  Show the version
 
 Import system:
   use "./utils.future"              Import all functions from a file
@@ -45,16 +48,22 @@ Import system:
 
 Flags:
   future run --debug <file>         Show timing for every namespace call
+  future compile --sourcemap <file> Also emit a .js.map source map
+  future ast --pretty <file>        Indented JSON output
 `;
 
 async function main(argv) {
-  const debug = argv.includes('--debug');
+  const debug     = argv.includes('--debug');
+  const sourcemap = argv.includes('--sourcemap');
+  const pretty    = argv.includes('--pretty');
   if (debug) process.env.FUTURE_DEBUG = '1';
-  const rest = argv.filter((a) => a !== '--debug');
+  const rest = argv.filter((a) => a !== '--debug' && a !== '--sourcemap' && a !== '--pretty');
   const [command, arg] = rest;
   switch (command) {
     case 'run':        return cmdRun(arg);
-    case 'compile':    return cmdCompile(arg);
+    case 'compile':    return cmdCompile(arg, { sourcemap });
+    case 'test':       return cmdTest(arg);
+    case 'ast':        return cmdAst(arg, { pretty });
     case 'new':        return cmdNew(arg);
     case 'check':      return cmdCheck(arg);
     case 'fmt':        return cmdFmt(arg);
@@ -198,7 +207,7 @@ function compileDepModule(source, sourcePath, tempDir, pathMap) {
 // Commands
 // ---------------------------------------------------------------------------
 
-function cmdCompile(file) {
+function cmdCompile(file, { sourcemap = false } = {}) {
   let path, source;
   try { ({ path, source } = readSource(file)); }
   catch (err) { return fail(err, file); }
@@ -230,18 +239,30 @@ function cmdCompile(file) {
     console.log(`Compiled ${relPath} -> ${depOut}`);
   }
 
-  const js = compileOrReport(source, file, {
+  const rawJs = compileOrReport(source, file, {
     runtimeSpecifier: relativeRuntimeSpecifier(outDir),
+    sourceMaps: sourcemap,
     resolveSource: (relPath) => {
       const abs = resolve(outDir, relPath);
       return existsSync(abs) ? readFileSync(abs, 'utf8') : null;
     },
   });
-  if (js === null) return 1;
-
-  const outPath = join(outDir, `${basename(path, extname(path))}.js`);
-  writeFileSync(outPath, js, 'utf8');
-  console.log(`Compiled ${file} -> ${outPath}`);
+  if (rawJs === null) return 1;
+
+  const outBase = join(outDir, basename(path, extname(path)));
+  const outPath = `${outBase}.js`;
+
+  if (sourcemap) {
+    const mapFile = `${outBase}.js.map`;
+    const { code, map } = buildSourceMap(rawJs, basename(file), source);
+    writeFileSync(outPath, `${code}//# sourceMappingURL=${basename(mapFile)}\n`, 'utf8');
+    writeFileSync(mapFile, JSON.stringify(map), 'utf8');
+    console.log(`Compiled ${file} -> ${outPath}`);
+    console.log(`Source map   -> ${mapFile}`);
+  } else {
+    writeFileSync(outPath, rawJs, 'utf8');
+    console.log(`Compiled ${file} -> ${outPath}`);
+  }
   return 0;
 }
 
@@ -328,6 +349,105 @@ function cmdFmt(file) {
   return 0;
 }
 
+/** Output the AST of a .future file as JSON. */
+function cmdAst(file, { pretty = false } = {}) {
+  let path, source;
+  try { ({ path, source } = readSource(file)); }
+  catch (err) { return fail(err, file); }
+
+  try {
+    const tokens = tokenize(source);
+    const ast    = parse(tokens);
+    process.stdout.write((pretty ? JSON.stringify(ast, null, 2) : JSON.stringify(ast)) + '\n');
+    return 0;
+  } catch (err) {
+    if (err instanceof FutureError) { reportFutureError(err, source, file); return 1; }
+    throw err;
+  }
+}
+
+/** Recursively collect .future files matching a pattern or default test globs. */
+function findTestFiles(pattern) {
+  const cwd = process.cwd();
+  const files = [];
+
+  function walk(dir) {
+    let entries;
+    try { entries = readdirSync(dir); } catch { return; }
+    for (const entry of entries) {
+      if (entry === 'node_modules') continue;
+      const full = join(dir, entry);
+      const st = statSync(full);
+      if (st.isDirectory()) { walk(full); continue; }
+      if (!entry.endsWith('.future')) continue;
+      const rel = relative(cwd, full).split('\\').join('/');
+      if (pattern) {
+        if (rel.includes(pattern) || entry.includes(pattern)) files.push(full);
+      } else {
+        if (entry.endsWith('.test.future') || rel.startsWith('test/')) files.push(full);
+      }
+    }
+  }
+
+  walk(cwd);
+  return files;
+}
+
+/** Run *.test.future files and report results. */
+async function cmdTest(pattern) {
+  const testFiles = findTestFiles(pattern);
+  if (testFiles.length === 0) {
+    process.stderr.write('No test files found.\n');
+    process.stderr.write('  Naming: *.test.future or test/**/*.future\n');
+    return 1;
+  }
+
+  const tempDir = tmpdir();
+  let passed = 0;
+  let failed = 0;
+
+  for (const testFile of testFiles) {
+    const rel = relative(process.cwd(), testFile).split('\\').join('/');
+    let source;
+    try { source = readFileSync(testFile, 'utf8'); } catch (err) { process.stderr.write(`error reading ${rel}: ${err.message}\n`); failed++; continue; }
+
+    // Compile dependencies.
+    const pathMap = compileDepsToTemp(testFile, source, tempDir);
+    if (pathMap === null) { failed++; continue; }
+
+    const js = compileOrReport(source, rel, {
+      runtimeSpecifier: pathToFileURL(RUNTIME_INDEX).href,
+      pathMap,
+      resolveSource: (p) => {
+        const abs = resolve(dirname(testFile), p);
+        return existsSync(abs) ? readFileSync(abs, 'utf8') : null;
+      },
+    });
+    if (js === null) { failed++; continue; }
+
+    const tmp = join(tempDir, `future-test-${process.pid}-${Date.now()}.mjs`);
+    writeFileSync(tmp, js, 'utf8');
+    const depTmps = [...pathMap.values()].map((u) => fileURLToPath(u));
+    try {
+      await import(pathToFileURL(tmp).href);
+      console.log(`  ✓ ${rel}`);
+      passed++;
+    } catch (err) {
+      const isAssert = err.name === 'AssertionError' || err.namespace === 'assert';
+      process.stderr.write(`  ✗ ${rel}\n`);
+      process.stderr.write(`    ${isAssert ? 'AssertionError' : err.name ?? 'Error'}: ${err.message}\n`);
+      failed++;
+    } finally {
+      try { unlinkSync(tmp); } catch { /* ignore */ }
+      for (const p of depTmps) { try { unlinkSync(p); } catch { /* ignore */ } }
+    }
+  }
+
+  const total = passed + failed;
+  console.log(`\n${passed}/${total} tests passed${failed > 0 ? `, ${failed} failed` : ''}`);
+  return failed > 0 ? 1 : 0;
+}
+
 /** Create a new project scaffold. */
 function cmdNew(name) {
   if (!name) {

package/src/generator.js

@@ -24,6 +24,7 @@ export const NAMESPACES = new Set([
   'rag', 'vision', 'home',              // AI / automation extension points
   'memory', 'schedule', 'system', 'device', // optional new modules
   'math',                               // general-purpose math
+  'assert',                             // test assertions
 ]);
 
 export class Generator {
@@ -36,6 +37,7 @@ export class Generator {
     this.runtimeSpecifier = options.runtimeSpecifier ?? 'future-lang/runtime';
     this.browserMode = options.browserMode ?? false;
     this.isModule = options.isModule ?? false;
+    this.sourceMaps = options.sourceMaps ?? false;
     // Map<importedFuturePath, string[]> — exported names for non-aliased use statements.
     this.importedNames = options.importedNames ?? new Map();
     // Map<importedFuturePath, resolvedJsPath> — path override for `future run` temp files.
@@ -79,7 +81,12 @@ export class Generator {
     }
     for (const stmt of program.body) {
       if (stmt.type === NodeType.UseStatement) continue; // already emitted above
-      lines.push(this.genStatement(stmt, 0, /* topLevel= */ true));
+      const code = this.genStatement(stmt, 0, /* topLevel= */ true);
+      if (this.sourceMaps && stmt.line != null) {
+        lines.push(`/*@FL:${stmt.line}*/${code}`);
+      } else {
+        lines.push(code);
+      }
     }
     return lines.join('\n') + '\n';
   }

package/src/parser.js

@@ -19,7 +19,7 @@ const EXPR_TERMINATORS = new Set(['END', 'ELSE', 'CATCH', 'EOF']);
 /** Built-in namespace names that cannot be redefined by user code. */
 const RESERVED_NAMESPACES = new Set([
   'ai', 'http', 'mqtt', 'tts', 'rag', 'vision', 'home',
-  'memory', 'schedule', 'system', 'device', 'math',
+  'memory', 'schedule', 'system', 'device', 'math', 'assert',
 ]);
 
 export class Parser {

package/src/sourcemap.js

@@ -0,0 +1,69 @@
+// src/sourcemap.js — Source map generation (Source Map v3).
+// The generator embeds @FL:N markers (inside block comments) at statement lines.
+// This module strips them and produces a v3 source map + clean JS.
+
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+function encodeVlq(value) {
+  let vlq = value < 0 ? ((-value) << 1) | 1 : (value << 1);
+  let out = '';
+  do {
+    let digit = vlq & 0x1F;
+    vlq >>>= 5;
+    if (vlq > 0) digit |= 0x20;
+    out += B64[digit];
+  } while (vlq > 0);
+  return out;
+}
+
+const MARKER_RE = /^\/\*@FL:(\d+)\*\//;
+
+/**
+ * Strip @FL:N markers from generated JS and build a v3 source map.
+ *
+ * @param {string} js           Generated JS (possibly with @FL markers)
+ * @param {string} sourceFile   Original .future filename (for `sources` field)
+ * @param {string} futureSource Original .future source text (for `sourcesContent`)
+ * @returns {{ code: string, map: object }}
+ */
+export function buildSourceMap(js, sourceFile, futureSource) {
+  const jsLines   = js.split('\n');
+  const cleanLines = [];
+  const mappings   = [];
+
+  // Delta state for VLQ.
+  let prevSrcLine = 0;
+  let prevSrcCol  = 0;
+
+  for (const line of jsLines) {
+    const m = MARKER_RE.exec(line);
+    if (m) {
+      const srcLine = parseInt(m[1], 10) - 1; // 0-indexed
+      const srcCol  = 0;
+      // Segment: [genCol=0, sourceIdx=0, srcLine delta, srcCol delta]
+      const seg = encodeVlq(0)
+        + encodeVlq(0)
+        + encodeVlq(srcLine - prevSrcLine)
+        + encodeVlq(srcCol  - prevSrcCol);
+      mappings.push(seg);
+      prevSrcLine = srcLine;
+      prevSrcCol  = srcCol;
+      cleanLines.push(line.slice(m[0].length));
+    } else {
+      // No marker — emit an empty mapping for this line.
+      mappings.push('');
+      cleanLines.push(line);
+    }
+  }
+
+  const map = {
+    version: 3,
+    file: sourceFile.replace(/\.future$/, '.js'),
+    sources: [sourceFile],
+    sourcesContent: [futureSource],
+    names: [],
+    mappings: mappings.join(';'),
+  };
+
+  return { code: cleanLines.join('\n'), map };
+}