@xnoxs/flux-lang 3.5.3 → 4.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "3.5.3",
+  "version": "4.0.1",
   "description": "Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
   "main": "dist/flux.cjs.js",
   "module": "dist/flux.esm.js",

package/src/self/codegen.flux

@@ -54,6 +54,7 @@ export class CodeGenerator:
   smBuilder: any
   _needsFmt: bool
   _loopDepth: int
+  _version: string
 
   fn i():
     var s = ''
@@ -83,7 +84,7 @@ export class CodeGenerator:
     self.lines     = []
     self.level     = 0
     self._needsFmt = false
-    self.emit('// Generated by Flux Transpiler v3.1.0 (self-hosted)')
+    self.emit('// Generated by Flux Transpiler v' + (self._version ?? "3.5.3") + ' (self-hosted)')
     self.emit('"use strict";')
     self.blank()
     for node in ast.body: self.genStmt(node)
@@ -111,6 +112,7 @@ export class CodeGenerator:
     else if node.type == 'TypeDecl':   self.genTypeDecl(node)
     else if node.type == 'InterfaceDecl': self.genInterfaceDecl(node)
     else if node.type == 'EnumDecl':   self.genEnumDecl(node)
+    else if node.type == 'DeclareDecl': return
     else if node.type == 'ExprStmt':   self.emit(self.genExpr(node.expr) + ';')
     else:
       throw new Error("Unknown statement: {node.type}")
@@ -552,4 +554,5 @@ export class CodeGenerator:
 export fn makeCodeGen(opts):
   val ind = opts?.indent ?? '    '
   val smb = opts?.smBuilder ?? null
-  return new CodeGenerator(ind, 0, [], {}, smb, false, 0)
+  val ver = opts?.version ?? "3.5.3"
+  return new CodeGenerator(ind, 0, [], {}, smb, false, 0, ver)

package/src/self/codegen.js

@@ -52,7 +52,7 @@ function getAllFields(name, reg, visited) {
   return [...parent, ...reg[name].fields];
 }
 class CodeGenerator {
-  constructor(ind, level, lines, clsReg, smBuilder, _needsFmt, _loopDepth) {
+  constructor(ind, level, lines, clsReg, smBuilder, _needsFmt, _loopDepth, _version) {
     this.ind = ind;
     this.level = level;
     this.lines = lines;
@@ -60,6 +60,7 @@ class CodeGenerator {
     this.smBuilder = smBuilder;
     this._needsFmt = _needsFmt;
     this._loopDepth = _loopDepth;
+    this._version = _version;
   }
 
   i() {
@@ -99,7 +100,7 @@ class CodeGenerator {
     this.lines = [];
     this.level = 0;
     this._needsFmt = false;
-    this.emit("// Generated by Flux Transpiler v3.1.0 (self-hosted)");
+    this.emit((("// Generated by Flux Transpiler v" + (this._version ?? "3.5.3")) + " (self-hosted)"));
     this.emit("\"use strict\";");
     this.blank();
     for (const node of ast.body) {
@@ -169,6 +170,9 @@ class CodeGenerator {
     else if ((node.type == "EnumDecl")) {
       this.genEnumDecl(node);
     }
+    else if ((node.type == "DeclareDecl")) {
+      return;
+    }
     else if ((node.type == "ExprStmt")) {
       this.emit((this.genExpr(node.expr) + ";"));
     }
@@ -789,6 +793,7 @@ module.exports.CodeGenerator = CodeGenerator;
 function makeCodeGen(opts) {
   const ind = (opts?.indent ?? "    ");
   const smb = (opts?.smBuilder ?? null);
-  return new CodeGenerator(ind, 0, [], {  }, smb, false, 0);
+  const ver = (opts?.version ?? "3.5.3");
+  return new CodeGenerator(ind, 0, [], {  }, smb, false, 0, ver);
 }
 module.exports.makeCodeGen = makeCodeGen;

package/src/self/lexer.flux

@@ -43,7 +43,7 @@ export val T = {
 export val TokenType = T
 
 val KEYWORDS = {
-  "var": 'VAR', "val": 'VAL', "fn": 'FN', "return": 'RETURN',
+  "var": 'VAR', "val": 'VAL', "fn": 'FN', "return": 'RETURN', "declare": 'DECLARE',
   "if": 'IF', "else": 'ELSE', "for": 'FOR', "in": 'IN',
   "while": 'WHILE', "break": 'BREAK', "continue": 'CONTINUE', "do": 'DO',
   "class": 'CLASS', "extends": 'EXTENDS', "self": 'SELF', "new": 'NEW',
@@ -345,7 +345,7 @@ export class Lexer:
         if word == '_' and not /[a-zA-Z0-9_]/.test(self.ch()):
           self.tok(T.WILDCARD, '_', l, c)
           continue
-        val kw = KEYWORDS[word]
+        val kw = Object.prototype.hasOwnProperty.call(KEYWORDS, word) ? KEYWORDS[word] : undefined
         if kw == '__TRUE__': self.tok(T.BOOL, true, l, c)
         else if kw == '__FALSE__': self.tok(T.BOOL, false, l, c)
         else if kw == '__NULL__': self.tok(T.NULL, null, l, c)

package/src/self/lexer.js

@@ -18,7 +18,7 @@ const T = { NUMBER: "NUMBER", STRING: "STRING", BOOL: "BOOL", NULL: "NULL", IDEN
 module.exports.T = T;
 const TokenType = T;
 module.exports.TokenType = TokenType;
-const KEYWORDS = { var: "VAR", val: "VAL", fn: "FN", return: "RETURN", if: "IF", else: "ELSE", for: "FOR", in: "IN", while: "WHILE", break: "BREAK", continue: "CONTINUE", do: "DO", class: "CLASS", extends: "EXTENDS", self: "SELF", new: "NEW", interface: "INTERFACE", implements: "IMPLEMENTS", private: "PRIVATE", public: "PUBLIC", protected: "PROTECTED", readonly: "READONLY", static: "STATIC", abstract: "ABSTRACT", override: "OVERRIDE", match: "MATCH", when: "WHEN", import: "IMPORT", export: "EXPORT", from: "FROM", as: "AS", default: "DEFAULT", and: "AND", or: "OR", not: "NOT", async: "ASYNC", await: "AWAIT", try: "TRY", catch: "CATCH", finally: "FINALLY", throw: "THROW", typeof: "TYPEOF", instanceof: "INSTANCEOF", type: "TYPE", enum: "ENUM", satisfies: "SATISFIES", is: "IS", const: "CONST", true: "__TRUE__", false: "__FALSE__", null: "__NULL__" };
+const KEYWORDS = { var: "VAR", val: "VAL", fn: "FN", return: "RETURN", declare: "DECLARE", if: "IF", else: "ELSE", for: "FOR", in: "IN", while: "WHILE", break: "BREAK", continue: "CONTINUE", do: "DO", class: "CLASS", extends: "EXTENDS", self: "SELF", new: "NEW", interface: "INTERFACE", implements: "IMPLEMENTS", private: "PRIVATE", public: "PUBLIC", protected: "PROTECTED", readonly: "READONLY", static: "STATIC", abstract: "ABSTRACT", override: "OVERRIDE", match: "MATCH", when: "WHEN", import: "IMPORT", export: "EXPORT", from: "FROM", as: "AS", default: "DEFAULT", and: "AND", or: "OR", not: "NOT", async: "ASYNC", await: "AWAIT", try: "TRY", catch: "CATCH", finally: "FINALLY", throw: "THROW", typeof: "TYPEOF", instanceof: "INSTANCEOF", type: "TYPE", enum: "ENUM", satisfies: "SATISFIES", is: "IS", const: "CONST", true: "__TRUE__", false: "__FALSE__", null: "__NULL__" };
 class Lexer {
   constructor(src, pos, line, col, tokens, indentStack, nestDepth) {
     this.src = src;
@@ -454,7 +454,7 @@ class Lexer {
           this.tok(T.WILDCARD, "_", l, c);
           continue;
         }
-        const kw = KEYWORDS[word];
+        const kw = (Object.prototype.hasOwnProperty.call(KEYWORDS, word) ? KEYWORDS[word] : undefined);
         if ((kw == "__TRUE__")) {
           this.tok(T.BOOL, true, l, c);
         }

package/src/self/parser.flux

@@ -85,6 +85,7 @@ export class Parser:
     if tok.type == T.FN:       return self.parseFnDecl(false)
     if tok.type == T.ASYNC:    return self.parseAsyncFn()
     if tok.type == T.CLASS:    return self.parseClassDecl()
+    if tok.type == T.DECLARE:  return self.parseDeclareDecl()
     if tok.type == T.IF:       return self.parseIf()
     if tok.type == T.FOR:      return self.parseFor()
     if tok.type == T.WHILE:    return self.parseWhile()
@@ -668,6 +669,46 @@ export class Parser:
     if not self.check(T.FN): self.err('Expected fn after async')
     return self.parseFnDecl(true)
 
+  fn parseDeclareDecl():
+    val loc = self.eat(T.DECLARE)
+    val tok = self.peek()
+
+    if tok.type == T.FN or tok.type == T.ASYNC:
+      val isAsync = tok.type == T.ASYNC
+      self.skip()
+      if isAsync: self.eat(T.FN)
+      val name = self.check(T.IDENT) ? self.skip().value : null
+      val params = self.parseParamList()
+      var retType = null
+      if self.check(T.ARROW):
+        self.pos = self.pos + 1
+        retType = self.parseTypeAnn()
+      else if self.check(T.COLON):
+        self.pos = self.pos + 1
+        retType = self.parseTypeAnn()
+      self.skipNewlines()
+      val decl = { type: 'FnDecl', name, params, retType, body: [], inline: false, async: isAsync, loc: tok }
+      return { type: 'DeclareDecl', decl, loc }
+
+    if tok.type == T.VAL or tok.type == T.VAR:
+      val kind = tok.type == T.VAR ? 'var' : 'val'
+      self.skip()
+      val name = self.eat(T.IDENT).value
+      var typeAnn = null
+      if self.maybe(T.COLON): typeAnn = self.parseTypeAnn()
+      self.skipNewlines()
+      val decl = { type: 'VarDecl', kind, name, typeAnn, init: null, loc: tok }
+      return { type: 'DeclareDecl', decl, loc }
+
+    if tok.type == T.CLASS:
+      self.skip()
+      val name = self.eat(T.IDENT).value
+      self.skipNewlines()
+      val decl = { type: 'ClassDecl', name, fields: [], methods: [], loc: tok }
+      return { type: 'DeclareDecl', decl, loc }
+
+    self.err('Expected fn, async fn, val, var, or class after declare')
+
   fn parseParamList():
     self.eat(T.LPAREN)
     val params = []

package/src/self/parser.js

@@ -121,6 +121,9 @@ class Parser {
     if ((tok.type == T.CLASS)) {
       return this.parseClassDecl();
     }
+    if ((tok.type == T.DECLARE)) {
+      return this.parseDeclareDecl();
+    }
     if ((tok.type == T.IF)) {
       return this.parseIf();
     }
@@ -921,6 +924,52 @@ class Parser {
     return this.parseFnDecl(true);
   }
 
+  parseDeclareDecl() {
+    const loc = this.eat(T.DECLARE);
+    const tok = this.peek();
+    if (((tok.type == T.FN) || (tok.type == T.ASYNC))) {
+      const isAsync = (tok.type == T.ASYNC);
+      this.skip();
+      if (isAsync) {
+        this.eat(T.FN);
+      }
+      const name = (this.check(T.IDENT) ? this.skip().value : null);
+      const params = this.parseParamList();
+      let retType = null;
+      if (this.check(T.ARROW)) {
+        this.pos = (this.pos + 1);
+        retType = this.parseTypeAnn();
+      }
+      else if (this.check(T.COLON)) {
+        this.pos = (this.pos + 1);
+        retType = this.parseTypeAnn();
+      }
+      this.skipNewlines();
+      const decl = { type: "FnDecl", name, params, retType, body: [], inline: false, async: isAsync, loc: tok };
+      return { type: "DeclareDecl", decl, loc };
+    }
+    if (((tok.type == T.VAL) || (tok.type == T.VAR))) {
+      const kind = ((tok.type == T.VAR) ? "var" : "val");
+      this.skip();
+      const name = this.eat(T.IDENT).value;
+      let typeAnn = null;
+      if (this.maybe(T.COLON)) {
+        typeAnn = this.parseTypeAnn();
+      }
+      this.skipNewlines();
+      const decl = { type: "VarDecl", kind, name, typeAnn, init: null, loc: tok };
+      return { type: "DeclareDecl", decl, loc };
+    }
+    if ((tok.type == T.CLASS)) {
+      this.skip();
+      const name = this.eat(T.IDENT).value;
+      this.skipNewlines();
+      const decl = { type: "ClassDecl", name, fields: [], methods: [], loc: tok };
+      return { type: "DeclareDecl", decl, loc };
+    }
+    this.err("Expected fn, async fn, val, var, or class after declare");
+  }
+
   parseParamList() {
     this.eat(T.LPAREN);
     const params = [];

package/src/self/pkg.flux

@@ -323,6 +323,82 @@ export async fn cmdInfo(name, opts):
   catch(e):
     err("Could not fetch info for " + name + ": " + e.message)
 
+// ── flux upgrade [--check] ────────────────────────────────────
+export async fn cmdUpgrade(opts):
+  val isCheck = opts?.check ?? false
+  val cwd     = process.cwd()
+  val pkg     = readPackage(cwd)
+
+  if not pkg:
+    err("No flux.json found. Run: flux init")
+    return
+
+  val deps    = pkg.dependencies ?? {}
+  val devDeps = pkg.devDependencies ?? {}
+  val all     = { ...deps, ...devDeps }
+  val names   = Object.keys(all)
+
+  if names.length == 0:
+    info("No dependencies to upgrade")
+    console.log()
+    return
+
+  if isCheck:
+    console.log(clr(C.cyan, "\n  Checking " + names.length + " package(s) for updates...\n"))
+  else:
+    console.log(clr(C.cyan, "\n  Upgrading " + names.length + " package(s) to latest...\n"))
+
+  var outdated = 0
+  var updated  = 0
+
+  for name in names:
+    val current = all[name]
+    val spinner = startSpinner("Checking " + clr(C.bold, name) + " ...")
+    try:
+      val info_ = await fetchJson(REGISTRY_URL + "/" + name)
+      val latest = info_["dist-tags"]?.latest ?? null
+      stopSpinner(spinner)
+
+      if not latest:
+        console.log("  " + clr(C.gray, "? ") + clr(C.bold, name) + clr(C.gray, " — could not resolve latest"))
+        continue
+
+      val currentClean = current.replace("^", "").replace("~", "")
+      if currentClean == latest:
+        console.log("  " + clr(C.green, "✓ ") + clr(C.bold, name) + clr(C.gray, " " + current + " (up to date)"))
+      else:
+        outdated = outdated + 1
+        if isCheck:
+          console.log("  " + clr(C.yellow, "↑ ") + clr(C.bold, name) + clr(C.gray, "  " + current + " → ") + clr(C.green, "^" + latest))
+        else:
+          val isDev = devDeps[name] != null
+          val depKey = isDev ? "devDependencies" : "dependencies"
+          pkg[depKey][name] = "^" + latest
+          updated = updated + 1
+          console.log("  " + clr(C.green, "✓ ") + clr(C.bold, name) + clr(C.gray, "  " + current + " → ") + clr(C.green, "^" + latest))
+
+    catch(e):
+      stopSpinner(spinner)
+      console.log("  " + clr(C.red, "✗ ") + clr(C.bold, name) + clr(C.gray, " — " + e.message))
+
+  console.log()
+
+  if isCheck:
+    if outdated == 0:
+      ok("All packages are up to date")
+    else:
+      console.log(clr(C.yellow, "  " + outdated + " package(s) can be upgraded"))
+      console.log(clr(C.gray, "  Run ") + clr(C.yellow, "flux upgrade") + clr(C.gray, " to apply updates"))
+  else:
+    if updated == 0:
+      ok("All packages are already up to date")
+    else:
+      saveFluxJson(pkg, cwd)
+      ok(updated + " package(s) updated in flux.json")
+      console.log(clr(C.gray, "  Run ") + clr(C.yellow, "flux install") + clr(C.gray, " to install updated versions"))
+
+  console.log()
+
 // ── flux publish ──────────────────────────────────────────────
 export fn cmdPublish(opts):
   val cwd = process.cwd()

package/src/self/pkg.js

@@ -310,6 +310,88 @@ async function cmdInfo(name, opts) {
   }
 }
 module.exports.cmdInfo = cmdInfo;
+async function cmdUpgrade(opts) {
+  const isCheck = (opts?.check ?? false);
+  const cwd = process.cwd();
+  const pkg = readPackage(cwd);
+  if (!pkg) {
+    err("No flux.json found. Run: flux init");
+    return;
+  }
+  const deps = (pkg.dependencies ?? {  });
+  const devDeps = (pkg.devDependencies ?? {  });
+  const all = { ...deps, ...devDeps };
+  const names = Object.keys(all);
+  if ((names.length == 0)) {
+    info("No dependencies to upgrade");
+    console.log();
+    return;
+  }
+  if (isCheck) {
+    console.log(clr(C.cyan, (("\n  Checking " + names.length) + " package(s) for updates...\n")));
+  }
+  else {
+    console.log(clr(C.cyan, (("\n  Upgrading " + names.length) + " package(s) to latest...\n")));
+  }
+  let outdated = 0;
+  let updated = 0;
+  for (const name of names) {
+    const current = all[name];
+    const spinner = startSpinner((("Checking " + clr(C.bold, name)) + " ..."));
+    try {
+      const info_ = await fetchJson(((REGISTRY_URL + "/") + name));
+      const latest = (info_["dist-tags"]?.latest ?? null);
+      stopSpinner(spinner);
+      if (!latest) {
+        console.log(((("  " + clr(C.gray, "? ")) + clr(C.bold, name)) + clr(C.gray, " — could not resolve latest")));
+        continue;
+      }
+      const currentClean = current.replace("^", "").replace("~", "");
+      if ((currentClean == latest)) {
+        console.log(((("  " + clr(C.green, "✓ ")) + clr(C.bold, name)) + clr(C.gray, ((" " + current) + " (up to date)"))));
+      }
+      else {
+        outdated = (outdated + 1);
+        if (isCheck) {
+          console.log((((("  " + clr(C.yellow, "↑ ")) + clr(C.bold, name)) + clr(C.gray, (("  " + current) + " → "))) + clr(C.green, ("^" + latest))));
+        }
+        else {
+          const isDev = (devDeps[name] != null);
+          const depKey = (isDev ? "devDependencies" : "dependencies");
+          pkg[depKey][name] = ("^" + latest);
+          updated = (updated + 1);
+          console.log((((("  " + clr(C.green, "✓ ")) + clr(C.bold, name)) + clr(C.gray, (("  " + current) + " → "))) + clr(C.green, ("^" + latest))));
+        }
+      }
+    }
+    catch (e) {
+      stopSpinner(spinner);
+      console.log(((("  " + clr(C.red, "✗ ")) + clr(C.bold, name)) + clr(C.gray, (" — " + e.message))));
+    }
+  }
+  console.log();
+  if (isCheck) {
+    if ((outdated == 0)) {
+      ok("All packages are up to date");
+    }
+    else {
+      console.log(clr(C.yellow, (("  " + outdated) + " package(s) can be upgraded")));
+      console.log(((clr(C.gray, "  Run ") + clr(C.yellow, "flux upgrade")) + clr(C.gray, " to apply updates")));
+    }
+  }
+  else {
+    if ((updated == 0)) {
+      ok("All packages are already up to date");
+    }
+    else {
+      saveFluxJson(pkg, cwd);
+      ok((updated + " package(s) updated in flux.json"));
+      console.log(((clr(C.gray, "  Run ") + clr(C.yellow, "flux install")) + clr(C.gray, " to install updated versions")));
+    }
+  }
+  console.log();
+}
+module.exports.cmdUpgrade = cmdUpgrade;
 function cmdPublish(opts) {
   const cwd = process.cwd();
   const pkg = readPackage(cwd);

package/src/self/transpiler.flux

@@ -1,5 +1,5 @@
 // ============================================================
-//  Flux Self-Hosted Transpiler — v3.0 (100% Self-Hosting)
+//  Flux Self-Hosted Transpiler — v3.5 (100% Self-Hosting)
 //  src/self/transpiler.flux — written in Flux, compiled by stage-0
 //
 //  Full pipeline:
@@ -15,8 +15,18 @@ import { transformJsx, FLUX_H_BROWSER, FLUX_H_SERVER, FLUX_CSS_BROWSER, FLUX_CSS
 import { Checker }                               from './checker'
 import { FluxTypeChecker }                       from './type-checker'
 
-// ── Version info ─────────────────────────────────────────────
-export val FLUX_VERSION = "3.0.0"
+// ── Version info — always in sync with package.json ──────────
+import Fs   from "fs"
+import Path from "path"
+
+fn _readFluxVersion():
+  try:
+    val pkgPath = Path.resolve(__dirname, "../../package.json")
+    return JSON.parse(Fs.readFileSync(pkgPath, "utf8")).version
+  catch(e):
+    return "4.0.1"
+
+export val FLUX_VERSION = _readFluxVersion()
 export val FLUX_STAGE   = "self-hosted"
 
 // ── Public API ────────────────────────────────────────────────
@@ -89,7 +99,7 @@ export fn transpile(source, options):
     // ── Stage 5: Code generation ────────────────────────────────
     result.stage = "codegen"
     val indent    = opts.mangle ? "" : "  "
-    val cg        = makeCodeGen({ indent })
+    val cg        = makeCodeGen({ indent, version: FLUX_VERSION })
     val genResult = cg.generate(ast)
     var code      = genResult.code
 

package/src/self/transpiler.js

@@ -8,7 +8,18 @@ const { transformCss } = require("./css-preprocessor");
 const { transformJsx, FLUX_H_BROWSER, FLUX_H_SERVER, FLUX_CSS_BROWSER, FLUX_CSS_SERVER } = require("./jsx");
 const { Checker } = require("./checker");
 const { FluxTypeChecker } = require("./type-checker");
-const FLUX_VERSION = "3.0.0";
+const Fs = require("fs");
+const Path = require("path");
+function _readFluxVersion() {
+  try {
+    const pkgPath = Path.resolve(__dirname, "../../package.json");
+    return JSON.parse(Fs.readFileSync(pkgPath, "utf8")).version;
+  }
+  catch (e) {
+    return "4.0.1";
+  }
+}
+const FLUX_VERSION = _readFluxVersion();
 module.exports.FLUX_VERSION = FLUX_VERSION;
 const FLUX_STAGE = "self-hosted";
 module.exports.FLUX_STAGE = FLUX_STAGE;
@@ -61,7 +72,7 @@ function transpile(source, options) {
     }
     result.stage = "codegen";
     const indent = (opts.mangle ? "" : "  ");
-    const cg = makeCodeGen({ indent });
+    const cg = makeCodeGen({ indent, version: FLUX_VERSION });
     const genResult = cg.generate(ast);
     let code = genResult.code;
     if (opts._jsxHelpers) {

package/src/self/type-checker.flux

@@ -734,6 +734,18 @@ export class FluxTypeChecker:
       clsEnv.set("self", T_OBJECT(shape))
       for m in node.methods: self._checkStmt(m, clsEnv)
 
+    else if node.type == "DeclareDecl":
+      val d = node.decl
+      if d.type == "FnDecl":
+        val retType    = d.retType ? parseAnnotation(d.retType) : null
+        val paramTypes = d.params.map(p -> p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN)
+        if d.name: env.set(d.name, T_FN(paramTypes, retType ?? T_UNKNOWN))
+      else if d.type == "VarDecl":
+        val t = d.typeAnn ? parseAnnotation(d.typeAnn) : T_UNKNOWN
+        env.set(d.name, t)
+      else if d.type == "ClassDecl":
+        env.set(d.name, T_NAMED(d.name))
+
     else if node.type == "TypeDecl":
       for v in node.variants:
         if v.fields.length == 0:

package/src/self/type-checker.js

@@ -995,6 +995,23 @@ class FluxTypeChecker {
         this._checkStmt(m, clsEnv);
       }
     }
+    else if ((node.type == "DeclareDecl")) {
+      const d = node.decl;
+      if ((d.type == "FnDecl")) {
+        const retType = (d.retType ? parseAnnotation(d.retType) : null);
+        const paramTypes = d.params.map((p) => (p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN));
+        if (d.name) {
+          env.set(d.name, T_FN(paramTypes, (retType ?? T_UNKNOWN)));
+        }
+      }
+      else if ((d.type == "VarDecl")) {
+        const t = (d.typeAnn ? parseAnnotation(d.typeAnn) : T_UNKNOWN);
+        env.set(d.name, t);
+      }
+      else if ((d.type == "ClassDecl")) {
+        env.set(d.name, T_NAMED(d.name));
+      }
+    }
     else if ((node.type == "TypeDecl")) {
       for (const v of node.variants) {
         if ((v.fields.length == 0)) {