@xnoxs/flux-lang 3.2.0 → 3.2.2

package/src/type-checker.js

@@ -1,1206 +0,0 @@
-'use strict';
-
-// ── Flux Type System v2.0 ──────────────────────────────────────────────────────
-// Full TypeScript-level type checking engine
-// Features: structural typing, union/intersection, nullable, generics, utility types,
-//           type narrowing, tuples, index signatures, keyof, typeof, conditional types
-
-// ── Primitive singletons ──────────────────────────────────────────────────────
-const T_ANY     = Object.freeze({ kind: 'any' });
-const T_UNKNOWN = Object.freeze({ kind: 'unknown' });
-const T_NEVER   = Object.freeze({ kind: 'never' });
-const T_VOID    = Object.freeze({ kind: 'void' });
-const T_NULL    = Object.freeze({ kind: 'null' });
-const T_STRING  = Object.freeze({ kind: 'primitive', name: 'String' });
-const T_INT     = Object.freeze({ kind: 'primitive', name: 'Int' });
-const T_FLOAT   = Object.freeze({ kind: 'primitive', name: 'Float' });
-const T_NUMBER  = Object.freeze({ kind: 'primitive', name: 'Number' });
-const T_BOOL    = Object.freeze({ kind: 'primitive', name: 'Bool' });
-
-// ── Type constructors ─────────────────────────────────────────────────────────
-function T_UNION(...members) {
-  const flat = [];
-  for (const m of members) {
-    if (m && m.kind === 'union') flat.push(...m.members);
-    else if (m) flat.push(m);
-  }
-  const seen = new Set();
-  const deduped = flat.filter(m => {
-    const k = typeStr(m);
-    if (seen.has(k)) return false;
-    seen.add(k); return true;
-  });
-  if (deduped.length === 0) return T_NEVER;
-  if (deduped.length === 1) return deduped[0];
-  return { kind: 'union', members: deduped };
-}
-
-function T_INTERSECTION(...members) {
-  const flat = [];
-  for (const m of members) {
-    if (m && m.kind === 'intersection') flat.push(...m.members);
-    else if (m) flat.push(m);
-  }
-  if (flat.length === 1) return flat[0];
-  return { kind: 'intersection', members: flat };
-}
-
-function T_ARRAY(elem) { return { kind: 'generic', name: 'Array', args: [elem || T_UNKNOWN] }; }
-function T_TUPLE(types) { return { kind: 'tuple', types: types || [] }; }
-function T_NULLABLE(t) { return T_UNION(t, T_NULL); }
-function T_NAMED(name) { return { kind: 'named', name }; }
-function T_FN(params, ret) { return { kind: 'fn', params: params || [], ret: ret || T_VOID }; }
-function T_OBJECT(shape) { return { kind: 'object', shape: shape || new Map() }; } // shape: Map<string, Type>
-function T_RECORD(key, val) { return { kind: 'record', key: key || T_STRING, val: val || T_UNKNOWN }; }
-function T_LITERAL(value, kind) { return { kind: 'literal', value, prim: kind }; } // 'foo', 42, true literal types
-
-// ── Type → display string ─────────────────────────────────────────────────────
-function typeStr(t) {
-  if (!t) return 'unknown';
-  switch (t.kind) {
-    case 'any':          return 'Any';
-    case 'unknown':      return 'Unknown';
-    case 'never':        return 'Never';
-    case 'void':         return 'Void';
-    case 'null':         return 'Null';
-    case 'primitive':    return t.name;
-    case 'literal':      return JSON.stringify(t.value);
-    case 'union':        return t.members.map(typeStr).join(' | ');
-    case 'intersection': return t.members.map(typeStr).join(' & ');
-    case 'tuple':        return '[' + t.types.map(typeStr).join(', ') + ']';
-    case 'object':       return '{' + [...(t.shape || new Map()).entries()].map(([k,v]) => `${k}: ${typeStr(v)}`).join(', ') + '}';
-    case 'record':       return `Record<${typeStr(t.key)}, ${typeStr(t.val)}>`;
-    case 'generic':      return t.name + (t.args && t.args.length ? '<' + t.args.map(typeStr).join(', ') + '>' : '');
-    case 'named':        return t.name;
-    case 'fn':           return `(${(t.params || []).map(typeStr).join(', ')}) -> ${typeStr(t.ret)}`;
-    case 'keyof':        return `keyof ${typeStr(t.inner)}`;
-    case 'conditional':  return `${typeStr(t.check)} extends ${typeStr(t.extends)} ? ${typeStr(t.then)} : ${typeStr(t.else)}`;
-    default:             return 'unknown';
-  }
-}
-
-// ── Split at top-level separator (respects <>, [], {}, ()) ───────────────────
-function splitAtTopLevel(str, sep) {
-  const parts = [];
-  let depth = 0, start = 0;
-  for (let i = 0; i < str.length; i++) {
-    const c = str[i];
-    if ('<([{'.includes(c)) depth++;
-    else if ('>)]}' .includes(c)) depth--;
-    else if (depth === 0 && str.slice(i, i + sep.length) === sep) {
-      parts.push(str.slice(start, i));
-      start = i + sep.length;
-      i += sep.length - 1;
-    }
-  }
-  parts.push(str.slice(start));
-  return parts.filter(p => p.trim().length > 0);
-}
-
-// ── Primitive type map ────────────────────────────────────────────────────────
-const PRIMITIVE_MAP = {
-  String: T_STRING,   string: T_STRING,
-  Int: T_INT,         int: T_INT,
-  Float: T_FLOAT,     float: T_FLOAT,
-  Number: T_NUMBER,   number: T_NUMBER,
-  Bool: T_BOOL,       boolean: T_BOOL, Boolean: T_BOOL, bool: T_BOOL,
-  Void: T_VOID,       void: T_VOID,
-  Never: T_NEVER,     never: T_NEVER,
-  Any: T_ANY,         any: T_ANY,
-  Unknown: T_UNKNOWN, unknown: T_UNKNOWN,
-  Null: T_NULL,       null: T_NULL, undefined: T_VOID,
-  Object: T_NAMED('Object'), object: T_NAMED('Object'),
-  Symbol: T_NAMED('Symbol'), symbol: T_NAMED('Symbol'),
-  BigInt: T_NAMED('BigInt'), bigint: T_NAMED('BigInt'),
-};
-
-// ── Parse annotation string → Type object ────────────────────────────────────
-function parseAnnotation(str) {
-  if (!str) return null;
-  str = str.trim();
-
-  // Strip outer parens: (A | B) → A | B
-  if (str.startsWith('(') && str.endsWith(')')) {
-    str = str.slice(1, -1).trim();
-  }
-
-  // Union: A | B | C (split at top-level ' | ')
-  const unionParts = splitAtTopLevel(str, ' | ');
-  if (unionParts.length > 1) {
-    return T_UNION(...unionParts.map(parseAnnotation));
-  }
-
-  // Intersection: A & B (split at top-level ' & ')
-  const intersectionParts = splitAtTopLevel(str, ' & ');
-  if (intersectionParts.length > 1) {
-    return T_INTERSECTION(...intersectionParts.map(parseAnnotation));
-  }
-
-  // Conditional type: T extends U ? A : B
-  const condMatch = str.match(/^(\w+)\s+extends\s+(.+?)\s*\?\s*(.+?)\s*:\s*(.+)$/);
-  if (condMatch) {
-    return {
-      kind: 'conditional',
-      check:   parseAnnotation(condMatch[1]),
-      extends: parseAnnotation(condMatch[2]),
-      then:    parseAnnotation(condMatch[3]),
-      else:    parseAnnotation(condMatch[4]),
-    };
-  }
-
-  // keyof T
-  if (str.startsWith('keyof ')) {
-    return { kind: 'keyof', inner: parseAnnotation(str.slice(6)) };
-  }
-
-  // typeof x
-  if (str.startsWith('typeof ')) {
-    return { kind: 'typeof', name: str.slice(7) };
-  }
-
-  // readonly T → same as T (readonly only prevents assignment, not type)
-  if (str.startsWith('readonly ')) {
-    return parseAnnotation(str.slice(9));
-  }
-
-  // infer T → Any (infer is used in conditional types)
-  if (str.startsWith('infer ')) {
-    return T_ANY;
-  }
-
-  // Function type: fn(T1, T2) -> RetType  OR  fn() -> Void
-  // Also handles arrow style: (T1, T2) -> RetType
-  const fnTypeMatch = str.match(/^fn\(([^)]*)\)\s*->\s*(.+)$/) ||
-                      str.match(/^\(([^)]*)\)\s*->\s*(.+)$/);
-  if (fnTypeMatch) {
-    const paramStr = fnTypeMatch[1].trim();
-    const retStr   = fnTypeMatch[2].trim();
-    const params   = paramStr ? splitAtTopLevel(paramStr, ', ').map(p => {
-      // Handle named param: "name: Type" → parse Type only
-      const ci = p.indexOf(':');
-      return parseAnnotation(ci >= 0 ? p.slice(ci + 1).trim() : p.trim());
-    }) : [];
-    return T_FN(params, parseAnnotation(retStr));
-  }
-
-  // Nullable shorthand: String?
-  if (str.endsWith('?')) {
-    return T_NULLABLE(parseAnnotation(str.slice(0, -1)));
-  }
-
-  // Array shorthand: String[]
-  if (str.endsWith('[]')) {
-    return T_ARRAY(parseAnnotation(str.slice(0, -2)));
-  }
-
-  // Tuple type: [String, Int, Bool]
-  if (str.startsWith('[') && str.endsWith(']')) {
-    const inner = str.slice(1, -1);
-    if (!inner.trim()) return T_TUPLE([]);
-    const parts = splitAtTopLevel(inner, ', ');
-    return T_TUPLE(parts.map(p => parseAnnotation(p.replace(/^\.\.\./, '').trim())));
-  }
-
-  // Inline object type: { key: Type, key2?: Type }
-  if (str.startsWith('{') && str.endsWith('}')) {
-    const inner = str.slice(1, -1).trim();
-    const shape = new Map();
-    if (inner) {
-      const pairs = splitAtTopLevel(inner, ', ');
-      for (const pair of pairs) {
-        // Index signature: [key: String]: Type
-        const idxMatch = pair.match(/^\[(\w+):\s*\w+\]:\s*(.+)$/);
-        if (idxMatch) {
-          shape.set(`[index]`, parseAnnotation(idxMatch[2]));
-          continue;
-        }
-        const colonIdx = pair.indexOf(':');
-        if (colonIdx >= 0) {
-          const rawKey = pair.slice(0, colonIdx).trim().replace(/^readonly\s+/, '');
-          const key    = rawKey.replace(/\?$/, '');
-          const opt    = rawKey.endsWith('?');
-          const valType = parseAnnotation(pair.slice(colonIdx + 1).trim());
-          shape.set(key, opt ? T_UNION(valType, T_VOID) : valType);
-        }
-      }
-    }
-    return T_OBJECT(shape);
-  }
-
-  // Generic / Utility types: Partial<T>, Record<K,V>, Array<T> etc.
-  const genericMatch = str.match(/^(\w+)<(.+)>$/s);
-  if (genericMatch) {
-    const name    = genericMatch[1];
-    const rawArgs = splitAtTopLevel(genericMatch[2], ', ');
-    const args    = rawArgs.map(a => parseAnnotation(a.trim()));
-
-    // Well-known utility types
-    switch (name) {
-      case 'Array':
-      case 'List':
-      case 'ReadonlyArray': return T_ARRAY(args[0] || T_UNKNOWN);
-      case 'NonNullable':   return resolveNonNullable(args[0]);
-      case 'Partial':       return { kind: 'utility', util: 'Partial',   inner: args[0] };
-      case 'Required':      return { kind: 'utility', util: 'Required',  inner: args[0] };
-      case 'Readonly':      return args[0]; // readonly is erased
-      case 'Record':        return T_RECORD(args[0] || T_STRING, args[1] || T_UNKNOWN);
-      case 'Pick':          return { kind: 'utility', util: 'Pick',   inner: args[0], keys: args[1] };
-      case 'Omit':          return { kind: 'utility', util: 'Omit',   inner: args[0], keys: args[1] };
-      case 'Exclude':       return { kind: 'utility', util: 'Exclude', inner: args[0], keys: args[1] };
-      case 'Extract':       return { kind: 'utility', util: 'Extract', inner: args[0], keys: args[1] };
-      case 'ReturnType':    return { kind: 'utility', util: 'ReturnType', inner: args[0] };
-      case 'InstanceType':  return { kind: 'utility', util: 'InstanceType', inner: args[0] };
-      case 'Parameters':    return { kind: 'utility', util: 'Parameters', inner: args[0] };
-      case 'Awaited':       return { kind: 'utility', util: 'Awaited',  inner: args[0] };
-      case 'Promise':       return { kind: 'generic',  name: 'Promise', args };
-      case 'Map':           return { kind: 'generic',  name: 'Map',     args };
-      case 'Set':           return { kind: 'generic',  name: 'Set',     args };
-      case 'WeakMap':       return { kind: 'generic',  name: 'WeakMap', args };
-      default:              return { kind: 'generic',  name, args };
-    }
-  }
-
-  // Primitive or named type
-  if (PRIMITIVE_MAP[str]) return PRIMITIVE_MAP[str];
-  return T_NAMED(str);
-}
-
-function resolveNonNullable(t) {
-  if (!t) return T_UNKNOWN;
-  if (t.kind === 'union') return T_UNION(...t.members.filter(m => m.kind !== 'null' && m.kind !== 'void'));
-  if (t.kind === 'null' || t.kind === 'void') return T_NEVER;
-  return t;
-}
-
-// ── Standalone type assignability (basic, no structural) ─────────────────────
-function isAssignable(from, to) {
-  return _basicAssignable(from, to);
-}
-
-function _basicAssignable(from, to) {
-  if (!from || !to) return true;
-  if (to.kind === 'any')     return true;
-  if (from.kind === 'any')   return true;
-  if (from.kind === 'never') return true;
-  if (to.kind === 'unknown') return true;
-
-  if (from.kind === 'void'  && to.kind === 'void')  return true;
-  if (from.kind === 'null'  && to.kind === 'null')  return true;
-  if (from.kind === 'never' && to.kind === 'never') return true;
-
-  // Null assignable to nullable
-  if (from.kind === 'null' && to.kind === 'union') {
-    return to.members.some(m => m.kind === 'null' || m.kind === 'any' || m.kind === 'void');
-  }
-
-  // From union: all members assignable to target
-  if (from.kind === 'union') {
-    return from.members.every(m => _basicAssignable(m, to));
-  }
-  // To union: from assignable to at least one member
-  if (to.kind === 'union') {
-    return to.members.some(m => _basicAssignable(from, m));
-  }
-
-  // From intersection: assignable if from is a subtype of to (any member)
-  if (from.kind === 'intersection') {
-    return from.members.some(m => _basicAssignable(m, to));
-  }
-  // To intersection: from must satisfy all members
-  if (to.kind === 'intersection') {
-    return to.members.every(m => _basicAssignable(from, m));
-  }
-
-  // Primitives
-  if (from.kind === 'primitive' && to.kind === 'primitive') {
-    if (from.name === to.name) return true;
-    if (to.name === 'Number' && ['Int','Float','Number'].includes(from.name)) return true;
-    if (to.name === 'Float'  && from.name === 'Int') return true;
-    // Aliases
-    if (from.name === 'Bool' && to.name === 'Boolean') return true;
-    if (from.name === 'Boolean' && to.name === 'Bool') return true;
-    return false;
-  }
-
-  // Literal to primitive
-  if (from.kind === 'literal' && to.kind === 'primitive') {
-    const map = { string: 'String', number: 'Number', boolean: 'Bool' };
-    return map[from.prim] === to.name || (from.prim === 'number' && ['Int','Float','Number'].includes(to.name));
-  }
-
-  // Named types
-  if (from.kind === 'named' && to.kind === 'named') return from.name === to.name || to.name === 'Object';
-
-  // Generic types
-  if (from.kind === 'generic' && to.kind === 'generic') {
-    const arrayNames = new Set(['Array','List','ReadonlyArray']);
-    if (from.name !== to.name) {
-      if (!(arrayNames.has(from.name) && arrayNames.has(to.name))) return false;
-    }
-    if (from.args.length !== to.args.length) return false;
-    return from.args.every((a, i) => _basicAssignable(a, to.args[i]));
-  }
-
-  // Tuple types
-  if (from.kind === 'tuple' && to.kind === 'tuple') {
-    if (from.types.length !== to.types.length) return false;
-    return from.types.every((t, i) => _basicAssignable(t, to.types[i]));
-  }
-  // Array literal assignable to tuple: [Float, Float] satisfies [Float, Float]
-  if (from.kind === 'generic' && from.name === 'Array' && to.kind === 'tuple') {
-    const elemType = from.args[0] || T_UNKNOWN;
-    if (elemType.kind === 'unknown') return true;
-    return to.types.every(t => _basicAssignable(elemType, t));
-  }
-
-  // Object types (structural): both are objects, check all keys in `to` exist in `from`
-  if (from.kind === 'object' && to.kind === 'object') {
-    for (const [key, toType] of to.shape) {
-      if (!from.shape.has(key)) return false;
-      if (!_basicAssignable(from.shape.get(key), toType)) return false;
-    }
-    return true;
-  }
-
-  // Object to named (basic)
-  if (from.kind === 'object' && to.kind === 'named') return true; // structural check done in class
-
-  // Function type assignability
-  if (from.kind === 'fn' && to.kind === 'fn') {
-    // Simplified: covariant return type, skip parameter variance for now
-    if (to.ret && from.ret) return _basicAssignable(from.ret, to.ret);
-    return true;
-  }
-  // Lambda/fn vs fn type
-  if ((from.kind === 'fn' || to.kind === 'fn') && (from.kind === 'fn' || to.kind === 'fn')) {
-    return true; // permissive — function shapes are hard to compare without inference
-  }
-
-  // Record assignability
-  if (from.kind === 'record' && to.kind === 'record') {
-    return _basicAssignable(from.val, to.val);
-  }
-
-  // Generic with object args (e.g. Array<{...}> vs Array<{...}>)
-  if (from.kind === 'generic' && to.kind === 'generic') {
-    // Already handled above for basic generics, but args may be objects
-    return true; // permissive when both are same generic name (handled above)
-  }
-
-  // Utility types
-  if (to.kind === 'utility') return true; // Too complex to fully evaluate standalone
-  if (from.kind === 'utility') return true;
-
-  return false;
-}
-
-// ── Merge two types (for inference) ──────────────────────────────────────────
-function mergeTypes(a, b) {
-  if (!a || a.kind === 'unknown') return b || T_UNKNOWN;
-  if (!b || b.kind === 'unknown') return a;
-  if (typeStr(a) === typeStr(b))  return a;
-  if (a.kind === 'any' || b.kind === 'any') return T_ANY;
-  return T_UNION(a, b);
-}
-
-// ── Type Environment ──────────────────────────────────────────────────────────
-class TypeEnv {
-  constructor(parent = null) {
-    this.parent  = parent;
-    this.vars    = new Map();
-    this.retType = parent ? parent.retType  : null;
-    this.isAsync = parent ? parent.isAsync  : false;
-  }
-
-  set(name, type)  { this.vars.set(name, type); }
-  has(name)        { let e = this; while (e) { if (e.vars.has(name)) return true; e = e.parent; } return false; }
-  get(name) {
-    let env = this;
-    while (env) {
-      if (env.vars.has(name)) return env.vars.get(name);
-      env = env.parent;
-    }
-    return null;
-  }
-
-  child()                       { return new TypeEnv(this); }
-  childFn(retType, isAsync = false) {
-    const e = new TypeEnv(this);
-    e.retType = retType;
-    e.isAsync = isAsync;
-    return e;
-  }
-
-  // Create a narrowed child scope
-  narrow(name, type) {
-    const child = new TypeEnv(this);
-    if (name && type) child.vars.set(name, type);
-    return child;
-  }
-}
-
-// ── Type Check Error ──────────────────────────────────────────────────────────
-class TypeCheckError {
-  constructor(message, loc, hint = null) {
-    this.message = message;
-    this.name    = 'TypeError';
-    this.hint    = hint;
-    if (loc) { this.line = loc.line; this.col = loc.col; }
-  }
-}
-
-// ── Main Type Checker ─────────────────────────────────────────────────────────
-class FluxTypeChecker {
-  constructor() {
-    this.errors     = [];
-    this.warnings   = [];
-    this.interfaces = new Map(); // name → InterfaceDecl
-    this.types      = new Map(); // name → TypeDecl (ADTs)
-    this.classes    = new Map(); // name → ClassDecl
-    this.enums      = new Map(); // name → EnumDecl
-    this.typeAliases = new Map(); // name → Type (from type alias declarations)
-  }
-
-  check(ast) {
-    this.errors      = [];
-    this.warnings    = [];
-    this.interfaces.clear();
-    this.types.clear();
-    this.classes.clear();
-    this.enums.clear();
-    this.typeAliases.clear();
-
-    this._collectDeclarations(ast.body);
-    this._validateImplementations();
-
-    const env = new TypeEnv();
-    this._registerBuiltins(env);
-    this._checkStmts(ast.body, env);
-
-    return { errors: this.errors, warnings: this.warnings };
-  }
-
-  _err(msg, loc, hint = null) { this.errors.push(new TypeCheckError(msg, loc, hint)); }
-  _warn(msg, loc, hint = null){ this.warnings.push(new TypeCheckError(msg, loc, hint)); }
-
-  // ── Pass 1: Collect declarations ──────────────────────────────────
-  _collectDeclarations(stmts) {
-    for (const node of stmts) {
-      const n = node.type === 'ExportDecl' ? node.decl : node;
-      if (!n) continue;
-      switch (n.type) {
-        case 'InterfaceDecl': this.interfaces.set(n.name, n); break;
-        case 'TypeDecl':      this.types.set(n.name, n);      break;
-        case 'ClassDecl':     this.classes.set(n.name, n);    break;
-        case 'EnumDecl':      this.enums.set(n.name, n);      break;
-      }
-    }
-  }
-
-  // ── Pass 2: Validate interface implementations ────────────────────
-  _validateImplementations() {
-    for (const [, cls] of this.classes) {
-      for (const ifaceName of cls.interfaces || []) {
-        this._checkInterfaceImpl(cls, ifaceName);
-      }
-    }
-  }
-
-  _checkInterfaceImpl(cls, ifaceName) {
-    const iface = this.interfaces.get(ifaceName);
-    if (!iface) {
-      this._warn(
-        `Class '${cls.name}' implements unknown interface '${ifaceName}'`,
-        cls.loc,
-        `Define 'interface ${ifaceName}' before use`
-      );
-      return;
-    }
-    for (const member of iface.members) {
-      if (member.kind === 'method') {
-        const impl = cls.methods.find(m => m.name === member.name);
-        if (!impl) {
-          this._err(
-            `Class '${cls.name}' does not implement method '${member.name}()' required by interface '${ifaceName}'`,
-            cls.loc,
-            `Add 'fn ${member.name}(${member.params.map(p => p.name + (p.typeAnn ? ': ' + p.typeAnn : '')).join(', ')})' to the class`
-          );
-        }
-      } else if (member.kind === 'field' && !member.optional) {
-        const hasField  = cls.fields.find(f => f.name === member.name);
-        const hasMethod = cls.methods.find(m => m.name === member.name);
-        if (!hasField && !hasMethod) {
-          this._err(
-            `Class '${cls.name}' is missing field '${member.name}' required by interface '${ifaceName}'`,
-            cls.loc,
-            `Add '${member.name}: ${member.typeAnn}' to the class`
-          );
-        }
-      }
-    }
-    for (const superIface of iface.superInterfaces || []) {
-      this._checkInterfaceImpl(cls, superIface);
-    }
-  }
-
-  // ── Structural typing: check if object type satisfies interface ───
-  _isStructurallyCompatible(objShape, typeName) {
-    const iface = this.interfaces.get(typeName);
-    if (!iface) {
-      // Check classes too
-      const cls = this.classes.get(typeName);
-      if (!cls) return false;
-      for (const field of cls.fields) {
-        if (!objShape.has(field.name) && !field.optional) return false;
-        if (field.typeAnn && objShape.has(field.name)) {
-          const expected = parseAnnotation(field.typeAnn);
-          const actual   = objShape.get(field.name);
-          if (!this._isAssignable(actual, expected)) return false;
-        }
-      }
-      return true;
-    }
-    for (const member of iface.members) {
-      if (member.kind === 'field' && !member.optional) {
-        if (!objShape.has(member.name)) return false;
-        if (member.typeAnn) {
-          const expected = parseAnnotation(member.typeAnn);
-          const actual   = objShape.get(member.name);
-          if (!this._isAssignable(actual, expected)) return false;
-        }
-      }
-    }
-    return true;
-  }
-
-  // ── Instance-level assignability (has structural typing access) ───
-  _isAssignable(from, to) {
-    if (!from || !to) return true;
-    if (to.kind === 'any')     return true;
-    if (from.kind === 'any')   return true;
-    if (from.kind === 'never') return true;
-    if (to.kind === 'unknown') return true;
-    if (from.kind === 'unknown') return false; // unknown must be narrowed
-
-    // Structural typing: object literal satisfies interface/class
-    if (from.kind === 'object' && to.kind === 'named') {
-      return this._isStructurallyCompatible(from.shape, to.name);
-    }
-
-    // Structural typing: object literal satisfies inline object type
-    if (from.kind === 'object' && to.kind === 'object') {
-      for (const [key, toType] of to.shape) {
-        if (!from.shape.has(key)) return false;
-        if (!this._isAssignable(from.shape.get(key), toType)) return false;
-      }
-      return true;
-    }
-
-    // Named satisfies interface (nominal → structural check)
-    if (from.kind === 'named' && to.kind === 'named') {
-      if (from.name === to.name) return true;
-      if (to.name === 'Object')  return true;
-      // Check if 'from' class implements 'to' interface
-      const cls = this.classes.get(from.name);
-      if (cls && (cls.interfaces || []).includes(to.name)) return true;
-      // Check class inheritance
-      if (cls && cls.superClass === to.name) return true;
-      // Check if 'from' interface extends 'to'
-      const iface = this.interfaces.get(from.name);
-      if (iface && (iface.superInterfaces || []).includes(to.name)) return true;
-      return false;
-    }
-
-    // Handle utility types
-    if (to.kind === 'utility') {
-      switch (to.util) {
-        case 'Partial':  return true; // partial accepts any object
-        case 'Required': return this._isAssignable(from, to.inner);
-        case 'NonNullable': return from.kind !== 'null' && from.kind !== 'void';
-        default: return true;
-      }
-    }
-    if (from.kind === 'utility') return true;
-
-    // Everything else: delegate to basic
-    return _basicAssignable(from, to);
-  }
-
-  // ── Extract narrowed type from condition ───────────────────────────
-  // Returns: { varName: string, trueType: Type, falseType: Type }
-  _analyzeNarrowingCondition(condExpr, env) {
-    if (!condExpr) return null;
-
-    // x != null  /  x !== null  /  x !== undefined
-    if (condExpr.type === 'BinaryExpr' &&
-        (condExpr.op === '!=' || condExpr.op === '!==') &&
-        condExpr.left.type === 'Identifier' &&
-        (condExpr.right.type === 'NullLit' ||
-         (condExpr.right.type === 'Identifier' && condExpr.right.name === 'undefined'))) {
-      const name = condExpr.left.name;
-      const t = env.get(name);
-      if (t && t.kind === 'union') {
-        const narrowed = T_UNION(...t.members.filter(m => m.kind !== 'null' && m.kind !== 'void'));
-        return { varName: name, trueType: narrowed, falseType: T_UNION(T_NULL, T_VOID) };
-      }
-    }
-
-    // x == null  /  x === null
-    if (condExpr.type === 'BinaryExpr' &&
-        (condExpr.op === '==' || condExpr.op === '===') &&
-        condExpr.left.type === 'Identifier' &&
-        condExpr.right.type === 'NullLit') {
-      const name = condExpr.left.name;
-      const t = env.get(name);
-      if (t && t.kind === 'union') {
-        const narrowed = T_UNION(...t.members.filter(m => m.kind !== 'null' && m.kind !== 'void'));
-        return { varName: name, trueType: T_NULL, falseType: narrowed };
-      }
-    }
-
-    // typeof x === "string" / "number" / "boolean"
-    if (condExpr.type === 'BinaryExpr' &&
-        (condExpr.op === '===' || condExpr.op === '==') &&
-        condExpr.left.type === 'TypeofExpr' &&
-        condExpr.left.operand.type === 'Identifier' &&
-        condExpr.right.type === 'StringLit') {
-      const name    = condExpr.left.operand.name;
-      const typeStr = condExpr.right.value;
-      const TYPE_MAP = {
-        'string': T_STRING, 'number': T_NUMBER, 'boolean': T_BOOL,
-        'object': T_NAMED('Object'), 'function': T_FN([], T_ANY),
-        'undefined': T_VOID, 'bigint': T_NAMED('BigInt'), 'symbol': T_NAMED('Symbol'),
-      };
-      const narrowedTrue = TYPE_MAP[typeStr] || T_UNKNOWN;
-      return { varName: name, trueType: narrowedTrue, falseType: env.get(name) || T_UNKNOWN };
-    }
-
-    // x instanceof Class
-    if (condExpr.type === 'BinaryExpr' && condExpr.op === 'instanceof' &&
-        condExpr.left.type === 'Identifier') {
-      const name = condExpr.left.name;
-      const cls  = condExpr.right.type === 'Identifier' ? condExpr.right.name : null;
-      if (cls) return { varName: name, trueType: T_NAMED(cls), falseType: env.get(name) || T_UNKNOWN };
-    }
-
-    // Boolean: x (x is truthy — remove null/undefined/false/0)
-    if (condExpr.type === 'Identifier') {
-      const name = condExpr.name;
-      const t = env.get(name);
-      if (t && t.kind === 'union') {
-        const narrowed = T_UNION(...t.members.filter(m => m.kind !== 'null' && m.kind !== 'void'));
-        return { varName: name, trueType: narrowed, falseType: T_UNION(T_NULL, T_VOID) };
-      }
-    }
-
-    return null;
-  }
-
-  // ── Register built-in globals ──────────────────────────────────────
-  _registerBuiltins(env) {
-    env.set('console',     T_NAMED('Console'));
-    env.set('process',     T_NAMED('Process'));
-    env.set('Math',        T_NAMED('Math'));
-    env.set('JSON',        T_NAMED('JSON'));
-    env.set('Date',        T_NAMED('Date'));
-    env.set('Promise',     T_NAMED('Promise'));
-    env.set('Error',       T_NAMED('Error'));
-    env.set('Buffer',      T_NAMED('Buffer'));
-    env.set('RegExp',      T_NAMED('RegExp'));
-    env.set('Map',         T_NAMED('Map'));
-    env.set('Set',         T_NAMED('Set'));
-    env.set('WeakMap',     T_NAMED('WeakMap'));
-    env.set('WeakSet',     T_NAMED('WeakSet'));
-    env.set('Symbol',      T_NAMED('Symbol'));
-    env.set('Proxy',       T_NAMED('Proxy'));
-    env.set('Reflect',     T_NAMED('Reflect'));
-    env.set('setTimeout',  T_FN([T_FN([], T_VOID), T_NUMBER], T_VOID));
-    env.set('setInterval', T_FN([T_FN([], T_VOID), T_NUMBER], T_VOID));
-    env.set('clearTimeout',  T_ANY);
-    env.set('clearInterval', T_ANY);
-    env.set('parseInt',    T_FN([T_STRING, T_INT], T_INT));
-    env.set('parseFloat',  T_FN([T_STRING], T_FLOAT));
-    env.set('isNaN',       T_FN([T_NUMBER], T_BOOL));
-    env.set('isFinite',    T_FN([T_NUMBER], T_BOOL));
-    env.set('require',     T_FN([T_STRING], T_ANY));
-    env.set('fetch',       T_FN([T_STRING], T_ANY));
-    env.set('print',       T_FN([], T_VOID));
-    env.set('undefined',   T_VOID);
-    env.set('Infinity',    T_NUMBER);
-    env.set('NaN',         T_NUMBER);
-    env.set('globalThis',  T_NAMED('Object'));
-    env.set('Object',      T_NAMED('Object'));
-    env.set('Array',       T_NAMED('Array'));
-    env.set('String',      T_NAMED('String'));
-    env.set('Number',      T_NAMED('Number'));
-    env.set('Boolean',     T_NAMED('Boolean'));
-    env.set('Function',    T_NAMED('Function'));
-  }
-
-  // ── Statement checking ─────────────────────────────────────────────
-  _checkStmts(stmts, env) {
-    for (const node of stmts) this._checkStmt(node, env);
-  }
-
-  _checkStmt(node, env) {
-    if (!node) return;
-    switch (node.type) {
-
-      case 'VarDecl': {
-        const declared = node.typeAnn ? parseAnnotation(node.typeAnn) : null;
-        let actual = null;
-        if (node.init) {
-          actual = this._inferType(node.init, env);
-        }
-        if (declared && actual && actual.kind !== 'unknown') {
-          if (!this._isAssignable(actual, declared)) {
-            this._err(
-              `Type '${typeStr(actual)}' is not assignable to '${node.name}: ${typeStr(declared)}'`,
-              node.loc,
-              `Change the value to match '${typeStr(declared)}' or update the annotation`
-            );
-          }
-        }
-        env.set(node.name, declared || actual || T_UNKNOWN);
-        break;
-      }
-
-      case 'DestructureDecl': {
-        const srcType = node.init ? this._inferType(node.init, env) : T_UNKNOWN;
-        if (node.patternType === 'object') {
-          for (const p of node.pattern) {
-            // Try to pull member type from srcType
-            let memberType = T_UNKNOWN;
-            if (srcType.kind === 'object' && srcType.shape.has(p.key)) {
-              memberType = srcType.shape.get(p.key);
-            }
-            env.set(p.alias, memberType);
-          }
-        } else {
-          for (let i = 0; i < node.pattern.length; i++) {
-            const p = node.pattern[i];
-            if (!p) continue;
-            let elemType = T_UNKNOWN;
-            if (srcType.kind === 'tuple' && srcType.types[i]) elemType = srcType.types[i];
-            else if (srcType.kind === 'generic' && srcType.name === 'Array') elemType = srcType.args[0] || T_UNKNOWN;
-            env.set(p.name, elemType);
-          }
-        }
-        break;
-      }
-
-      case 'FnDecl': {
-        const retType = node.retType ? parseAnnotation(node.retType) : null;
-        const paramTypes = node.params.map(p => p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
-        if (node.name) env.set(node.name, T_FN(paramTypes, retType || T_UNKNOWN));
-
-        const fnEnv = env.childFn(retType, node.async);
-        for (let i = 0; i < node.params.length; i++) {
-          fnEnv.set(node.params[i].name, paramTypes[i]);
-        }
-
-        if (node.inline) {
-          const bodyType = this._inferType(node.body, fnEnv);
-          if (retType && bodyType && bodyType.kind !== 'unknown') {
-            if (!this._isAssignable(bodyType, retType)) {
-              this._err(
-                `Function '${node.name || '(anon)'}' returns '${typeStr(bodyType)}' but declared '${typeStr(retType)}'`,
-                node.loc,
-                `Fix return type or update the annotation`
-              );
-            }
-          }
-        } else {
-          this._checkStmts(node.body, fnEnv);
-        }
-        break;
-      }
-
-      case 'ClassDecl': {
-        env.set(node.name, T_NAMED(node.name));
-        const clsEnv = env.child();
-        // Build shape for structural typing later
-        const shape = new Map();
-        for (const f of node.fields) {
-          const ft = f.typeAnn ? parseAnnotation(f.typeAnn) : T_UNKNOWN;
-          clsEnv.set(f.name, ft);
-          shape.set(f.name, ft);
-        }
-        clsEnv.set('self', T_OBJECT(shape));
-        for (const m of node.methods) {
-          this._checkStmt(m, clsEnv);
-        }
-        break;
-      }
-
-      case 'TypeDecl':
-        for (const v of node.variants) {
-          if (v.fields.length === 0) env.set(v.name, T_NAMED(node.name));
-          else env.set(v.name, T_FN(v.fields.map(() => T_ANY), T_NAMED(node.name)));
-        }
-        break;
-
-      case 'InterfaceDecl':
-        env.set(node.name, T_NAMED(node.name));
-        break;
-
-      case 'EnumDecl':
-        env.set(node.name, T_NAMED(node.name));
-        break;
-
-      case 'IfStmt': {
-        this._inferType(node.cond, env);
-        // Type narrowing via control flow
-        const narrowing = this._analyzeNarrowingCondition(node.cond, env);
-        const thenEnv = narrowing ? env.narrow(narrowing.varName, narrowing.trueType) : env.child();
-        const elseEnv = narrowing ? env.narrow(narrowing.varName, narrowing.falseType) : env.child();
-
-        this._checkStmts(node.then, thenEnv);
-        for (const ei of node.elseifs) {
-          this._inferType(ei.cond, env);
-          this._checkStmts(ei.body, env.child());
-        }
-        if (node.else_) this._checkStmts(node.else_, elseEnv);
-        break;
-      }
-
-      case 'ForInStmt': {
-        const iterType = this._inferType(node.iter, env);
-        const inner = env.child();
-        if (iterType.kind === 'generic' && iterType.args.length > 0) inner.set(node.var, iterType.args[0]);
-        else if (iterType.kind === 'tuple' && iterType.types.length > 0) inner.set(node.var, T_UNION(...iterType.types));
-        else inner.set(node.var, T_UNKNOWN);
-        this._checkStmts(node.body, inner);
-        break;
-      }
-
-      case 'WhileStmt':
-        this._inferType(node.cond, env);
-        this._checkStmts(node.body, env.child());
-        break;
-
-      case 'DoWhileStmt':
-        this._checkStmts(node.body, env.child());
-        this._inferType(node.cond, env);
-        break;
-
-      case 'MatchStmt':
-        this._inferType(node.subject, env);
-        for (const arm of node.arms) {
-          const inner = env.child();
-          if (arm.pattern.type === 'VariantPat') {
-            for (const b of arm.pattern.bindings) inner.set(b, T_UNKNOWN);
-          }
-          if (arm.guard) this._inferType(arm.guard, inner);
-          this._checkStmts(arm.body, inner);
-        }
-        break;
-
-      case 'ReturnStmt': {
-        const retType = env.retType;
-        if (node.value) {
-          const actual = this._inferType(node.value, env);
-          if (retType && actual && actual.kind !== 'unknown' && retType.kind !== 'unknown') {
-            const effectiveRet = env.isAsync && retType.kind === 'generic' && retType.name === 'Promise'
-              ? retType.args[0]
-              : retType;
-            if (!this._isAssignable(actual, effectiveRet)) {
-              this._err(
-                `Return type '${typeStr(actual)}' is not assignable to declared '${typeStr(effectiveRet)}'`,
-                node.loc,
-                `Fix return expression or update return type annotation`
-              );
-            }
-          }
-        } else if (retType && retType.kind !== 'void' && retType.kind !== 'any' && retType.kind !== 'unknown') {
-          this._warn(
-            `Missing return value — function declares return type '${typeStr(retType)}'`,
-            node.loc
-          );
-        }
-        break;
-      }
-
-      case 'ThrowStmt':
-        this._inferType(node.value, env);
-        break;
-
-      case 'TryCatchStmt': {
-        this._checkStmts(node.tryBody, env.child());
-        if (node.catchBody) {
-          const inner = env.child();
-          if (node.catchParam) inner.set(node.catchParam, T_UNION(T_NAMED('Error'), T_UNKNOWN));
-          this._checkStmts(node.catchBody, inner);
-        }
-        if (node.finallyBody) this._checkStmts(node.finallyBody, env.child());
-        break;
-      }
-
-      case 'ImportDecl':
-        if (node.defaultName) env.set(node.defaultName, T_ANY);
-        if (node.namespaceName) env.set(node.namespaceName, T_ANY);
-        for (const n of node.names) env.set(typeof n === 'string' ? n : n.alias, T_ANY);
-        break;
-
-      case 'ExportDecl':
-        this._checkStmt(node.decl, env);
-        break;
-
-      case 'ExprStmt':
-        this._inferType(node.expr, env);
-        break;
-
-      case 'BreakStmt':
-      case 'ContinueStmt':
-        break;
-    }
-  }
-
-  // ── Type inference ──────────────────────────────────────────────────
-  _inferType(expr, env) {
-    if (!expr) return T_VOID;
-    switch (expr.type) {
-
-      case 'NumberLit':
-        return Number.isInteger(expr.value) ? T_INT : T_FLOAT;
-
-      case 'StringLit':
-      case 'TemplateLit':
-        return T_STRING;
-
-      case 'BoolLit':   return T_BOOL;
-      case 'NullLit':   return T_NULL;
-      case 'RegexLit':  return T_ANY;
-      case 'SelfExpr':  return env.get('self') || T_UNKNOWN;
-
-      case 'Identifier': {
-        const t = env.get(expr.name);
-        if (t) return t;
-        if (this.classes.has(expr.name)) return T_NAMED(expr.name);
-        if (this.enums.has(expr.name))   return T_NAMED(expr.name);
-        if (this.interfaces.has(expr.name)) return T_NAMED(expr.name);
-        return T_UNKNOWN;
-      }
-
-      case 'ArrayExpr': {
-        if (!expr.items || expr.items.length === 0) return T_ARRAY(T_UNKNOWN);
-        const elemTypes = expr.items
-          .filter(i => i && i.type !== 'SpreadExpr')
-          .map(i => this._inferType(i, env));
-        return T_ARRAY(elemTypes.reduce(mergeTypes, T_UNKNOWN));
-      }
-
-      case 'ObjectExpr': {
-        const shape = new Map();
-        for (const pair of expr.pairs || []) {
-          if (pair.spread) continue;
-          shape.set(String(pair.key), this._inferType(pair.value, env));
-        }
-        return T_OBJECT(shape);
-      }
-
-      case 'NewExpr':
-        for (const a of expr.args) this._inferType(a, env);
-        return T_NAMED(expr.callee);
-
-      case 'CallExpr': {
-        const calleeType = this._inferType(expr.callee, env);
-        for (const a of expr.args) this._inferType(a, env);
-        if (calleeType && calleeType.kind === 'fn') {
-          this._checkCallArgs(expr, calleeType, env);
-          return calleeType.ret || T_UNKNOWN;
-        }
-        return T_UNKNOWN;
-      }
-
-      case 'OptCallExpr':
-        this._inferType(expr.callee, env);
-        for (const a of expr.args) this._inferType(a, env);
-        return T_UNKNOWN;
-
-      case 'MemberExpr':
-      case 'OptMemberExpr': {
-        const objType = this._inferType(expr.obj, env);
-        // Try to resolve member type from known shapes
-        if (objType.kind === 'object' && objType.shape.has(expr.prop)) {
-          return objType.shape.get(expr.prop);
-        }
-        return T_UNKNOWN;
-      }
-
-      case 'IndexExpr':
-      case 'OptIndexExpr': {
-        const objType = this._inferType(expr.obj, env);
-        this._inferType(expr.idx, env);
-        if (objType.kind === 'generic' && objType.args.length > 0) return objType.args[0];
-        if (objType.kind === 'tuple') return T_UNION(...objType.types);
-        if (objType.kind === 'record') return objType.val;
-        return T_UNKNOWN;
-      }
-
-      case 'BinaryExpr': {
-        const left  = this._inferType(expr.left, env);
-        const right = this._inferType(expr.right, env);
-        const op    = expr.op;
-
-        if (['+','-','*','/','%','**'].includes(op)) {
-          if (left.kind === 'primitive'  && left.name === 'String')  return T_STRING;
-          if (right.kind === 'primitive' && right.name === 'String') return T_STRING;
-          if (left.kind === 'unknown' || right.kind === 'unknown')  return T_UNKNOWN;
-          if (left.kind === 'any'     || right.kind === 'any')      return T_NUMBER;
-          if (left.kind === 'primitive' && right.kind === 'primitive') {
-            const ln = left.name, rn = right.name;
-            if (ln === 'Int'   && rn === 'Int')   return T_INT;
-            if (['Float','Int'].includes(ln) && ['Float','Int'].includes(rn)) return T_FLOAT;
-          }
-          return T_NUMBER;
-        }
-        if (['===','!==','==','!=','<','<=','>','>=','&&','||','instanceof','in'].includes(op)) return T_BOOL;
-        if (op === '??') return mergeTypes(left, right);
-        if (['&','|','^','<<','>>'].includes(op)) return T_INT;
-        return T_UNKNOWN;
-      }
-
-      case 'UnaryExpr': {
-        const operand = this._inferType(expr.operand, env);
-        if (expr.op === '!' || expr.op === 'not') return T_BOOL;
-        if (expr.op === '-') {
-          if (operand.kind === 'primitive' && operand.name === 'Int')   return T_INT;
-          if (operand.kind === 'primitive' && operand.name === 'Float') return T_FLOAT;
-          return T_NUMBER;
-        }
-        if (expr.op === '~') return T_INT;
-        return operand;
-      }
-
-      case 'UpdateExpr':
-        this._inferType(expr.operand, env);
-        return T_NUMBER;
-
-      case 'TernaryExpr': {
-        const narrowing = this._analyzeNarrowingCondition(expr.cond, env);
-        const thenEnv = narrowing ? env.narrow(narrowing.varName, narrowing.trueType) : env;
-        const elseEnv = narrowing ? env.narrow(narrowing.varName, narrowing.falseType) : env;
-        this._inferType(expr.cond, env);
-        const then  = this._inferType(expr.then, thenEnv);
-        const else_ = this._inferType(expr.else_, elseEnv);
-        return mergeTypes(then, else_);
-      }
-
-      case 'AssignExpr': {
-        const valueType  = this._inferType(expr.value, env);
-        const targetType = this._inferType(expr.target, env);
-        if (targetType && targetType.kind !== 'unknown' && valueType && valueType.kind !== 'unknown') {
-          if (!this._isAssignable(valueType, targetType)) {
-            this._err(
-              `Cannot assign '${typeStr(valueType)}' to type '${typeStr(targetType)}'`,
-              expr.target.loc || expr.loc,
-              `Ensure the value matches the declared type`
-            );
-          }
-        }
-        return valueType;
-      }
-
-      case 'AwaitExpr': {
-        const inner = this._inferType(expr.operand, env);
-        if (inner.kind === 'generic' && inner.name === 'Promise') return inner.args[0] || T_UNKNOWN;
-        return T_UNKNOWN;
-      }
-
-      case 'TypeofExpr':
-        this._inferType(expr.operand, env);
-        return T_STRING;
-
-      case 'PipeExpr':
-        this._inferType(expr.left, env);
-        return this._inferType(expr.right, env);
-
-      case 'SpreadExpr':
-        this._inferType(expr.expr, env);
-        return T_UNKNOWN;
-
-      case 'RangeExpr':
-        this._inferType(expr.start, env);
-        this._inferType(expr.end, env);
-        return T_ARRAY(T_INT);
-
-      case 'LambdaExpr': {
-        const inner = env.child();
-        for (const p of expr.params) inner.set(p.name, p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
-        const ret = this._inferType(expr.body, inner);
-        const paramTypes = expr.params.map(p => p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
-        return T_FN(paramTypes, ret);
-      }
-
-      case 'FnDecl': {
-        const retType = expr.retType ? parseAnnotation(expr.retType) : null;
-        const inner   = env.childFn(retType, expr.async);
-        for (const p of expr.params || []) inner.set(p.name, p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
-        const paramTypes = (expr.params || []).map(p => p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
-        if (expr.inline) {
-          const bodyType = this._inferType(expr.body, inner);
-          return T_FN(paramTypes, retType || bodyType);
-        }
-        this._checkStmts(expr.body, inner);
-        return T_FN(paramTypes, retType || T_UNKNOWN);
-      }
-
-      case 'CastExpr':
-        this._inferType(expr.expr, env);
-        return expr.castType ? parseAnnotation(expr.castType) : T_ANY;
-
-      case 'SatisfiesExpr':
-      case 'NonNullExpr':
-      case 'AsConstExpr': {
-        const t = this._inferType(expr.expr, env);
-        if (expr.type === 'SatisfiesExpr' && expr.satType) {
-          const expected = parseAnnotation(expr.satType);
-          if (!this._isAssignable(t, expected)) {
-            this._err(`Type '${typeStr(t)}' does not satisfy '${typeStr(expected)}'`, expr.loc);
-          }
-        }
-        return t;
-      }
-
-      case 'IsExpr':
-        this._inferType(expr.expr, env);
-        return T_BOOL;
-
-      default:
-        return T_UNKNOWN;
-    }
-  }
-
-  // ── Check call arguments ──────────────────────────────────────────
-  _checkCallArgs(callExpr, fnType, env) {
-    const args   = callExpr.args || [];
-    const params = fnType.params || [];
-    for (let i = 0; i < args.length; i++) {
-      const argType   = this._inferType(args[i], env);
-      const paramType = params[i] || T_ANY;
-      if (paramType.kind !== 'any' && argType && argType.kind !== 'unknown') {
-        if (!this._isAssignable(argType, paramType)) {
-          this._err(
-            `Argument ${i+1}: '${typeStr(argType)}' is not assignable to '${typeStr(paramType)}'`,
-            callExpr.loc,
-            `Check function signature`
-          );
-        }
-      }
-    }
-  }
-}
-
-module.exports = {
-  FluxTypeChecker,
-  parseAnnotation,
-  typeStr,
-  isAssignable,
-  mergeTypes,
-  splitAtTopLevel,
-  T_ANY, T_UNKNOWN, T_NEVER, T_VOID, T_NULL,
-  T_STRING, T_INT, T_FLOAT, T_NUMBER, T_BOOL,
-  T_UNION, T_INTERSECTION, T_ARRAY, T_TUPLE, T_NULLABLE,
-  T_NAMED, T_FN, T_OBJECT, T_RECORD, T_LITERAL,
-};