@xnoxs/flux-lang 3.1.1

package/src/self/bundler.flux

@@ -0,0 +1,167 @@
+// ============================================================
+//  Flux Self-Hosted Bundler
+//  src/self/bundler.flux — written in Flux, compiled by stage-0
+//
+//  Bundles multiple Flux modules into a single JS file.
+// ============================================================
+
+import Fs   from "fs"
+import Path from "path"
+import { lexerize }      from './lexer'
+import { makeParser }    from './parser'
+import { makeCodeGen }   from './codegen'
+
+fn toModuleId(absPath):
+  val base = Path.basename(absPath, '.flux')
+  return '_flux_' + base.replace(/[^a-zA-Z0-9]/g, '_')
+
+fn extractModuleInfo(ast, fromFile):
+  val imports = []
+  val exports = []
+  val body    = []
+  val dir     = Path.dirname(fromFile)
+
+  for node in ast.body:
+    if node.type == 'ImportDecl':
+      var src = node.source
+      if not src.endsWith('.flux'): src = src + '.flux'
+      val absPath = Path.resolve(dir, src)
+      imports.push({ names: node.names, source: node.source, absPath })
+
+    else if node.type == 'ExportDecl':
+      val inner = node.decl
+      if inner.type == 'FnDecl':    exports.push(inner.name)
+      if inner.type == 'ClassDecl': exports.push(inner.name)
+      if inner.type == 'VarDecl':   exports.push(inner.name)
+      body.push(inner)
+
+    else:
+      body.push(node)
+
+  return { cleanAst: { type: 'Program', body }, imports, exports }
+
+fn codegenModule(ast):
+  val cg = makeCodeGen({ indent: '    ' })
+  val result = cg.generate(ast)
+  val lines = result.code.split('\n')
+  val start = lines.findIndex(l -> l.trim() != '' and not l.includes('Generated by Flux') and not l.includes('"use strict"'))
+  return lines.slice(start).join('\n')
+
+export class Bundler:
+  entryFile: string
+  options:   any
+  modules:   any
+  order:     any[]
+  visited:   any
+  inStack:   any
+
+  fn bundle():
+    self.collect(self.entryFile)
+    return self.link()
+
+  fn collect(absPath):
+    if self.visited.has(absPath): return
+    if self.inStack.has(absPath):
+      throw new Error("[" + Path.basename(absPath) + "] Circular dependency detected: " + absPath)
+    if not Fs.existsSync(absPath):
+      throw new Error("[" + Path.basename(absPath) + "] File not found: " + absPath)
+
+    self.inStack.add(absPath)
+
+    val source = Fs.readFileSync(absPath, 'utf8')
+
+    var ast = null
+    try:
+      val tokens = lexerize(source).tokenize()
+      ast = makeParser(tokens).parse()
+    catch(e):
+      throw new Error("[" + Path.basename(absPath) + "] Parse error: " + e.message)
+
+    val info = extractModuleInfo(ast, absPath)
+    self.modules.set(absPath, { cleanAst: info.cleanAst, imports: info.imports, exports: info.exports, source, absPath })
+
+    for imp in info.imports:
+      self.collect(imp.absPath)
+
+    self.inStack.delete(absPath)
+    self.visited.add(absPath)
+    self.order.push(absPath)
+
+  fn link():
+    val lines  = []
+    val banner = self.options.banner != false
+
+    if banner:
+      lines.push('// Generated by Flux Bundler (self-hosted)')
+      lines.push('// Entry: ' + Path.basename(self.entryFile))
+      lines.push('// Modules: ' + self.order.length)
+      lines.push('"use strict";')
+      lines.push('')
+
+    lines.push('(function() {')
+    lines.push('')
+
+    for absPath in self.order:
+      val mod     = self.modules.get(absPath)
+      val isEntry = absPath == self.entryFile
+      val modId   = toModuleId(absPath)
+      val relName = Path.relative(process.cwd(), absPath)
+
+      lines.push('  // ' + '─'.repeat(60))
+      lines.push('  // Module: ' + relName)
+      lines.push('  // ' + '─'.repeat(60))
+
+      if not isEntry:
+        lines.push('  var ' + modId + ' = (function() {')
+        lines.push('    var _exports = {};')
+        lines.push('')
+
+      for imp in mod.imports:
+        val srcId = toModuleId(imp.absPath)
+        if imp.names.length == 1:
+          lines.push('    var ' + imp.names[0] + ' = ' + srcId + ';')
+        else:
+          for name in imp.names:
+            lines.push('    var ' + name + ' = ' + srcId + '._exports ? ' + srcId + '._exports.' + name + ' : ' + srcId + '.' + name + ';')
+
+      if mod.imports.length > 0: lines.push('')
+
+      val moduleCode = codegenModule(mod.cleanAst)
+      lines.push(moduleCode)
+
+      if not isEntry:
+        if mod.exports.length > 0:
+          lines.push('')
+          for expName in mod.exports:
+            lines.push('    _exports.' + expName + ' = ' + expName + ';')
+        lines.push('')
+        lines.push('    return _exports;')
+        lines.push('  })()')
+        lines.push('  ' + modId + '._exports = ' + modId + ';')
+
+      lines.push('')
+
+    lines.push('})();')
+    return { code: lines.join('\n'), modules: self.order.length }
+
+export fn makeBundler(entryFile, options):
+  return new Bundler(
+    Path.resolve(entryFile),
+    options ?? {},
+    new Map(),
+    [],
+    new Set(),
+    new Set()
+  )
+
+export fn bundle(entryFile, options):
+  val result = { success: false, code: '', modules: 0, errors: [] }
+  try:
+    val b = makeBundler(entryFile, options)
+    val out = b.bundle()
+    result.code    = out.code
+    result.modules = out.modules
+    result.success = true
+  catch(e):
+    result.errors.push({ message: e.message, name: e.name, file: null })
+  return result

package/src/self/bundler.js

@@ -0,0 +1,187 @@
+// ── Flux stdlib ──
+
+function findIndex(arr, fn) { return arr.findIndex(fn); }
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+
+function includes(arr, val) { return arr.includes(val); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.1.0
+"use strict";
+
+const Fs = require("fs");
+const Path = require("path");
+const { lexerize } = require("./lexer");
+const { makeParser } = require("./parser");
+const { makeCodeGen } = require("./codegen");
+function toModuleId(absPath) {
+  const base = Path.basename(absPath, ".flux");
+  return ("_flux_" + base.replace(/[^a-zA-Z0-9]/g, "_"));
+}
+function extractModuleInfo(ast, fromFile) {
+  const imports = [];
+  const exports = [];
+  const body = [];
+  const dir = Path.dirname(fromFile);
+  for (const node of ast.body) {
+    if ((node.type == "ImportDecl")) {
+      let src = node.source;
+      if (!src.endsWith(".flux")) {
+        src = (src + ".flux");
+      }
+      const absPath = Path.resolve(dir, src);
+      imports.push({ names: node.names, source: node.source, absPath });
+    }
+    else if ((node.type == "ExportDecl")) {
+      const inner = node.decl;
+      if ((inner.type == "FnDecl")) {
+        exports.push(inner.name);
+      }
+      if ((inner.type == "ClassDecl")) {
+        exports.push(inner.name);
+      }
+      if ((inner.type == "VarDecl")) {
+        exports.push(inner.name);
+      }
+      body.push(inner);
+    }
+    else {
+      body.push(node);
+    }
+  }
+  return { cleanAst: { type: "Program", body }, imports, exports };
+}
+function codegenModule(ast) {
+  const cg = makeCodeGen({ indent: "    " });
+  const result = cg.generate(ast);
+  const lines = result.code.split("\n");
+  const start = lines.findIndex((l) => (((l.trim() != "") && !l.includes("Generated by Flux")) && !l.includes("\"use strict\"")));
+  return lines.slice(start).join("\n");
+}
+class Bundler {
+  constructor(entryFile, options, modules, order, visited, inStack) {
+    this.entryFile = entryFile;
+    this.options = options;
+    this.modules = modules;
+    this.order = order;
+    this.visited = visited;
+    this.inStack = inStack;
+  }
+
+  bundle() {
+    this.collect(this.entryFile);
+    return this.link();
+  }
+
+  collect(absPath) {
+    if (this.visited.has(absPath)) {
+      return;
+    }
+    if (this.inStack.has(absPath)) {
+      throw new Error(((("[" + Path.basename(absPath)) + "] Circular dependency detected: ") + absPath));
+    }
+    if (!Fs.existsSync(absPath)) {
+      throw new Error(((("[" + Path.basename(absPath)) + "] File not found: ") + absPath));
+    }
+    this.inStack.add(absPath);
+    const source = Fs.readFileSync(absPath, "utf8");
+    let ast = null;
+    try {
+      const tokens = lexerize(source).tokenize();
+      ast = makeParser(tokens).parse();
+    }
+    catch (e) {
+      throw new Error(((("[" + Path.basename(absPath)) + "] Parse error: ") + e.message));
+    }
+    const info = extractModuleInfo(ast, absPath);
+    this.modules.set(absPath, { cleanAst: info.cleanAst, imports: info.imports, exports: info.exports, source, absPath });
+    for (const imp of info.imports) {
+      this.collect(imp.absPath);
+    }
+    this.inStack.delete(absPath);
+    this.visited.add(absPath);
+    this.order.push(absPath);
+  }
+
+  link() {
+    const lines = [];
+    const banner = (this.options.banner != false);
+    if (banner) {
+      lines.push("// Generated by Flux Bundler (self-hosted)");
+      lines.push(("// Entry: " + Path.basename(this.entryFile)));
+      lines.push(("// Modules: " + this.order.length));
+      lines.push("\"use strict\";");
+      lines.push("");
+    }
+    lines.push("(function() {");
+    lines.push("");
+    for (const absPath of this.order) {
+      const mod = this.modules.get(absPath);
+      const isEntry = (absPath == this.entryFile);
+      const modId = toModuleId(absPath);
+      const relName = Path.relative(process.cwd(), absPath);
+      lines.push(("  // " + "─".repeat(60)));
+      lines.push(("  // Module: " + relName));
+      lines.push(("  // " + "─".repeat(60)));
+      if (!isEntry) {
+        lines.push((("  var " + modId) + " = (function() {"));
+        lines.push("    var _exports = {};");
+        lines.push("");
+      }
+      for (const imp of mod.imports) {
+        const srcId = toModuleId(imp.absPath);
+        if ((imp.names.length == 1)) {
+          lines.push((((("    var " + imp.names[0]) + " = ") + srcId) + ";"));
+        }
+        else {
+          for (const name of imp.names) {
+            lines.push((((((((((((("    var " + name) + " = ") + srcId) + "._exports ? ") + srcId) + "._exports.") + name) + " : ") + srcId) + ".") + name) + ";"));
+          }
+        }
+      }
+      if ((mod.imports.length > 0)) {
+        lines.push("");
+      }
+      const moduleCode = codegenModule(mod.cleanAst);
+      lines.push(moduleCode);
+      if (!isEntry) {
+        if ((mod.exports.length > 0)) {
+          lines.push("");
+          for (const expName of mod.exports) {
+            lines.push((((("    _exports." + expName) + " = ") + expName) + ";"));
+          }
+        }
+        lines.push("");
+        lines.push("    return _exports;");
+        lines.push("  })()");
+        lines.push((((("  " + modId) + "._exports = ") + modId) + ";"));
+      }
+      lines.push("");
+    }
+    lines.push("})();");
+    return { code: lines.join("\n"), modules: this.order.length };
+  }
+
+}
+
+module.exports.Bundler = Bundler;
+function makeBundler(entryFile, options) {
+  return new Bundler(Path.resolve(entryFile), (options ?? {  }), new Map(), [], new Set(), new Set());
+}
+module.exports.makeBundler = makeBundler;
+function bundle(entryFile, options) {
+  const result = { success: false, code: "", modules: 0, errors: [] };
+  try {
+    const b = makeBundler(entryFile, options);
+    const out = b.bundle();
+    result.code = out.code;
+    result.modules = out.modules;
+    result.success = true;
+  }
+  catch (e) {
+    result.errors.push({ message: e.message, name: e.name, file: null });
+  }
+  return result;
+}
+module.exports.bundle = bundle;

package/src/self/checker.flux

@@ -0,0 +1,249 @@
+// ============================================================
+//  Flux Self-Hosted Static Checker
+//  src/self/checker.flux — written in Flux, compiled by stage-0
+//
+//  Checks val immutability and basic scope correctness.
+// ============================================================
+
+export class CheckError:
+  message: any
+  loc: any
+  hint: any
+  name: any
+  line: any
+  col: any
+
+export class Scope:
+  parent: any
+  vars: any
+
+  fn define(name, kind, loc):
+    self.vars.set(name, { kind, loc })
+
+  fn lookup(name):
+    var scope = self
+    while scope:
+      if scope.vars.has(name): return scope.vars.get(name)
+      scope = scope.parent
+    return null
+
+  fn isVal(name):
+    val entry = self.lookup(name)
+    return entry and entry.kind == "val"
+
+export class Checker:
+  errors: any[]
+  warnings: any[]
+
+  fn error(msg, loc, hint):
+    val err = new CheckError()
+    err.message = msg
+    err.loc  = loc
+    err.hint = hint ?? null
+    err.name = "CheckError"
+    if loc:
+      err.line = loc.line
+      err.col  = loc.col
+    self.errors.push(err)
+
+  fn warn(msg, loc, hint):
+    val w = new CheckError()
+    w.message = msg
+    w.loc  = loc
+    w.hint = hint ?? null
+    w.name = "CheckError"
+    if loc:
+      w.line = loc.line
+      w.col  = loc.col
+    self.warnings.push(w)
+
+  fn check(ast):
+    self.errors   = []
+    self.warnings = []
+    val scope = new Scope(null, new Map())
+    self.walkStmts(ast.body, scope)
+    return { errors: self.errors, warnings: self.warnings }
+
+  fn walkStmts(stmts, scope):
+    for node in stmts: self.walkStmt(node, scope)
+
+  fn walkStmt(node, scope):
+    if not node: return
+
+    if node.type == "VarDecl":
+      if node.init: self.walkExpr(node.init, scope)
+      scope.define(node.name, node.kind, node.loc)
+
+    else if node.type == "DestructureDecl":
+      if node.init: self.walkExpr(node.init, scope)
+      if node.patternType == "object":
+        for p in node.pattern: scope.define(p.alias, node.kind, node.loc)
+      else:
+        for p in node.pattern:
+          if p: scope.define(p.name, node.kind, node.loc)
+
+    else if node.type == "FnDecl":
+      val inner = new Scope(scope, new Map())
+      for p in node.params: inner.define(p.name, "val", node.loc)
+      if node.name: scope.define(node.name, "val", node.loc)
+      if node.inline:
+        self.walkExpr(node.body, inner)
+      else:
+        self.walkStmts(node.body, inner)
+
+    else if node.type == "ClassDecl":
+      scope.define(node.name, "val", node.loc)
+      val cls = new Scope(scope, new Map())
+      for f in node.fields: cls.define(f.name, "var", node.loc)
+      for m in node.methods: self.walkStmt(m, cls)
+
+    else if node.type == "TypeDecl":
+      for v in node.variants: scope.define(v.name, "val", node.loc)
+
+    else if node.type == "InterfaceDecl":
+      scope.define(node.name, "val", node.loc)
+
+    else if node.type == "EnumDecl":
+      scope.define(node.name, "val", node.loc)
+
+    else if node.type == "IfStmt":
+      self.walkExpr(node.cond, scope)
+      self.walkStmts(node.then, new Scope(scope, new Map()))
+      for ei in node.elseifs:
+        self.walkExpr(ei.cond, scope)
+        self.walkStmts(ei.body, new Scope(scope, new Map()))
+      if node.else_: self.walkStmts(node.else_, new Scope(scope, new Map()))
+
+    else if node.type == "ForInStmt":
+      self.walkExpr(node.iter, scope)
+      val inner = new Scope(scope, new Map())
+      inner.define(node.var, "val", node.loc)
+      self.walkStmts(node.body, inner)
+
+    else if node.type == "WhileStmt":
+      self.walkExpr(node.cond, scope)
+      self.walkStmts(node.body, new Scope(scope, new Map()))
+
+    else if node.type == "DoWhileStmt":
+      self.walkStmts(node.body, new Scope(scope, new Map()))
+      self.walkExpr(node.cond, scope)
+
+    else if node.type == "MatchStmt":
+      self.walkExpr(node.subject, scope)
+      for arm in node.arms:
+        val inner = new Scope(scope, new Map())
+        if arm.pattern.type == "VariantPat":
+          for b in arm.pattern.bindings: inner.define(b, "val", node.loc)
+        if arm.guard: self.walkExpr(arm.guard, inner)
+        self.walkStmts(arm.body, inner)
+
+    else if node.type == "ReturnStmt":
+      if node.value: self.walkExpr(node.value, scope)
+
+    else if node.type == "ThrowStmt":
+      self.walkExpr(node.value, scope)
+
+    else if node.type == "TryCatchStmt":
+      self.walkStmts(node.tryBody, new Scope(scope, new Map()))
+      if node.catchBody:
+        val inner = new Scope(scope, new Map())
+        if node.catchParam: inner.define(node.catchParam, "val", node.loc)
+        self.walkStmts(node.catchBody, inner)
+      if node.finallyBody: self.walkStmts(node.finallyBody, new Scope(scope, new Map()))
+
+    else if node.type == "ImportDecl":
+      if node.defaultName: scope.define(node.defaultName, "val", node.loc)
+      if node.namespaceName: scope.define(node.namespaceName, "val", node.loc)
+      for n in node.names:
+        val nm = typeof n == "string" ? n : n.alias
+        scope.define(nm, "val", node.loc)
+
+    else if node.type == "ExportDecl":
+      if node.isDefault:
+        self.walkExpr(node.decl, scope)
+      else:
+        self.walkStmt(node.decl, scope)
+
+    else if node.type == "ExprStmt":
+      self.walkExpr(node.expr, scope)
+
+  fn walkExpr(node, scope):
+    if not node: return
+
+    if node.type == "AssignExpr":
+      val target = node.target
+      if target.type == "Identifier":
+        if scope.isVal(target.name):
+          self.error(
+            "Cannot reassign 'val " + target.name + "' — val is immutable",
+            target.loc,
+            "Use 'var " + target.name + "' if you need a mutable variable"
+          )
+      self.walkExpr(node.target, scope)
+      self.walkExpr(node.value, scope)
+
+    else if node.type == "UpdateExpr":
+      if node.operand.type == "Identifier" and scope.isVal(node.operand.name):
+        self.error(
+          "Cannot apply '" + node.op + "' to 'val " + node.operand.name + "' — val is immutable",
+          node.operand.loc,
+          "Use 'var " + node.operand.name + "' if you need a mutable variable"
+        )
+      self.walkExpr(node.operand, scope)
+
+    else if node.type == "BinaryExpr" or node.type == "PipeExpr":
+      self.walkExpr(node.left, scope)
+      self.walkExpr(node.right, scope)
+
+    else if node.type == "UnaryExpr" or node.type == "AwaitExpr" or node.type == "TypeofExpr":
+      self.walkExpr(node.operand, scope)
+
+    else if node.type == "TernaryExpr":
+      self.walkExpr(node.cond,  scope)
+      self.walkExpr(node.then,  scope)
+      self.walkExpr(node.else_, scope)
+
+    else if node.type == "CallExpr" or node.type == "OptCallExpr":
+      self.walkExpr(node.callee, scope)
+      for a in node.args: self.walkExpr(a, scope)
+
+    else if node.type == "MemberExpr" or node.type == "OptMemberExpr":
+      self.walkExpr(node.obj, scope)
+
+    else if node.type == "IndexExpr" or node.type == "OptIndexExpr":
+      self.walkExpr(node.obj, scope)
+      self.walkExpr(node.idx, scope)
+
+    else if node.type == "NewExpr":
+      for a in node.args: self.walkExpr(a, scope)
+
+    else if node.type == "ArrayExpr":
+      for item in node.items:
+        if item: self.walkExpr(item, scope)
+
+    else if node.type == "ObjectExpr":
+      for pair in node.pairs:
+        if pair.value: self.walkExpr(pair.value, scope)
+
+    else if node.type == "SpreadExpr":
+      self.walkExpr(node.expr, scope)
+
+    else if node.type == "LambdaExpr":
+      val inner = new Scope(scope, new Map())
+      for p in node.params: inner.define(p.name, "val", null)
+      self.walkExpr(node.body, inner)
+
+    else if node.type == "FnDecl":
+      val inner = new Scope(scope, new Map())
+      for p in node.params: inner.define(p.name, "val", null)
+      if node.inline:
+        self.walkExpr(node.body, inner)
+      else:
+        self.walkStmts(node.body, inner)
+
+    else if node.type == "CastExpr" or node.type == "AsConstExpr" or node.type == "SatisfiesExpr" or node.type == "IsExpr" or node.type == "NonNullExpr":
+      self.walkExpr(node.expr, scope)
+
+    else if node.type == "RangeExpr":
+      self.walkExpr(node.start, scope)
+      self.walkExpr(node.end,   scope)