@xnoxs/flux-lang 3.1.1

package/src/self/type-checker.flux

@@ -0,0 +1,821 @@
+// ============================================================
+//  Flux Self-Hosted Type Checker
+//  src/self/type-checker.flux — written in Flux, compiled by stage-0
+//
+//  Full TypeScript-level type checking engine.
+//  Features: structural typing, union/intersection, nullable,
+//            generics, utility types, type narrowing, tuples,
+//            conditional types, function types, interface enforcement
+// ============================================================
+
+// ── Primitive singletons ──────────────────────────────────────────────────────
+export val T_ANY     = Object.freeze({ kind: "any" })
+export val T_UNKNOWN = Object.freeze({ kind: "unknown" })
+export val T_NEVER   = Object.freeze({ kind: "never" })
+export val T_VOID    = Object.freeze({ kind: "void" })
+export val T_NULL    = Object.freeze({ kind: "null" })
+export val T_STRING  = Object.freeze({ kind: "primitive", name: "String" })
+export val T_INT     = Object.freeze({ kind: "primitive", name: "Int" })
+export val T_FLOAT   = Object.freeze({ kind: "primitive", name: "Float" })
+export val T_NUMBER  = Object.freeze({ kind: "primitive", name: "Number" })
+export val T_BOOL    = Object.freeze({ kind: "primitive", name: "Bool" })
+
+// ── Type constructors ─────────────────────────────────────────────────────────
+export fn T_UNION(...members):
+  val flat = []
+  for m in members:
+    if m and m.kind == "union":
+      for sub in m.members: flat.push(sub)
+    else if m:
+      flat.push(m)
+  val seen = new Set()
+  val deduped = []
+  for m in flat:
+    val k = typeStr(m)
+    if not seen.has(k):
+      seen.add(k)
+      deduped.push(m)
+  if deduped.length == 0: return T_NEVER
+  if deduped.length == 1: return deduped[0]
+  return { kind: "union", members: deduped }
+
+export fn T_INTERSECTION(...members):
+  val flat = []
+  for m in members:
+    if m and m.kind == "intersection":
+      for sub in m.members: flat.push(sub)
+    else if m:
+      flat.push(m)
+  if flat.length == 1: return flat[0]
+  return { kind: "intersection", members: flat }
+
+export fn T_ARRAY(elem):
+  return { kind: "generic", name: "Array", args: [elem ?? T_UNKNOWN] }
+
+export fn T_TUPLE(types):
+  return { kind: "tuple", types: types ?? [] }
+
+export fn T_NULLABLE(t):
+  return T_UNION(t, T_NULL)
+
+export fn T_NAMED(name):
+  return { kind: "named", name }
+
+export fn T_FN(params, ret):
+  return { kind: "fn", params: params ?? [], ret: ret ?? T_VOID }
+
+export fn T_OBJECT(shape):
+  return { kind: "object", shape: shape ?? new Map() }
+
+export fn T_RECORD(key, val_):
+  return { kind: "record", key: key ?? T_STRING, val: val_ ?? T_UNKNOWN }
+
+export fn T_LITERAL(value, kind):
+  return { kind: "literal", value, prim: kind }
+
+// ── Type → display string ─────────────────────────────────────────────────────
+export fn typeStr(t):
+  if not t: return "unknown"
+  if t.kind == "any":          return "Any"
+  if t.kind == "unknown":      return "Unknown"
+  if t.kind == "never":        return "Never"
+  if t.kind == "void":         return "Void"
+  if t.kind == "null":         return "Null"
+  if t.kind == "primitive":    return t.name
+  if t.kind == "literal":      return JSON.stringify(t.value)
+  if t.kind == "union":        return t.members.map(typeStr).join(" | ")
+  if t.kind == "intersection": return t.members.map(typeStr).join(" & ")
+  if t.kind == "tuple":        return "[" + t.types.map(typeStr).join(", ") + "]"
+  if t.kind == "object":
+    val entries = []
+    for pair in (t.shape ?? new Map()).entries():
+      entries.push(pair[0] + ': ' + typeStr(pair[1]))
+    return '{' + entries.join(', ') + '}'
+  if t.kind == "record":       return "Record<" + typeStr(t.key) + ", " + typeStr(t.val) + ">"
+  if t.kind == "generic":
+    if t.args and t.args.length > 0:
+      return t.name + "<" + t.args.map(typeStr).join(", ") + ">"
+    return t.name
+  if t.kind == "named":        return t.name
+  if t.kind == "fn":
+    return "(" + (t.params ?? []).map(typeStr).join(", ") + ") -> " + typeStr(t.ret)
+  if t.kind == "keyof":        return "keyof " + typeStr(t.inner)
+  if t.kind == "conditional":
+    return typeStr(t.check) + " extends " + typeStr(t.extends) + " ? " + typeStr(t.then) + " : " + typeStr(t.else)
+  return "unknown"
+
+// ── Split at top-level separator ──────────────────────────────────────────────
+fn splitAtTopLevel(str, sep):
+  val parts = []
+  var depth = 0
+  var start = 0
+  var i = 0
+  while i < str.length:
+    val c = str[i]
+    if '<([{'.includes(c): depth = depth + 1
+    else if '>)]}'.includes(c): depth = depth - 1
+    else if depth == 0 and str.slice(i, i + sep.length) == sep:
+      parts.push(str.slice(start, i))
+      start = i + sep.length
+      i = i + sep.length - 1
+    i = i + 1
+  parts.push(str.slice(start))
+  return parts.filter(p -> p.trim().length > 0)
+
+// ── Primitive type map ─────────────────────────────────────────────────────────
+val 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 ────────────────────────────────────────────
+export fn parseAnnotation(str):
+  if not str: return null
+  var s = str.trim()
+
+  // Strip outer parens
+  if s.startsWith("(") and s.endsWith(")"):
+    s = s.slice(1, -1).trim()
+
+  // Union
+  val unionParts = splitAtTopLevel(s, " | ")
+  if unionParts.length > 1:
+    return T_UNION(...unionParts.map(parseAnnotation))
+
+  // Intersection
+  val interParts = splitAtTopLevel(s, " & ")
+  if interParts.length > 1:
+    return T_INTERSECTION(...interParts.map(parseAnnotation))
+
+  // Conditional type: T extends U ? A : B
+  val condMatch = s.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 s.startsWith("keyof "):
+    return { kind: "keyof", inner: parseAnnotation(s.slice(6)) }
+
+  // typeof x
+  if s.startsWith("typeof "):
+    return { kind: "typeof", name: s.slice(7) }
+
+  // readonly T
+  if s.startsWith("readonly "):
+    return parseAnnotation(s.slice(9))
+
+  // infer T → Any
+  if s.startsWith("infer "):
+    return T_ANY
+
+  // Function type: fn(T1, T2) -> Ret  OR  (T1, T2) -> Ret
+  val fnMatch = s.match(/^fn\(([^)]*)\)\s*->\s*(.+)$/) ?? s.match(/^\(([^)]*)\)\s*->\s*(.+)$/)
+  if fnMatch:
+    val paramStr = fnMatch[1].trim()
+    val retStr   = fnMatch[2].trim()
+    val params = paramStr ? splitAtTopLevel(paramStr, ", ").map(p -> parseAnnotation(p.slice(p.indexOf(":") >= 0 ? p.indexOf(":") + 1 : 0).trim())) : []
+    return T_FN(params, parseAnnotation(retStr))
+
+  // Nullable shorthand: String?
+  if s.endsWith("?"):
+    return T_NULLABLE(parseAnnotation(s.slice(0, -1)))
+
+  // Array shorthand: String[]
+  if s.endsWith("[]"):
+    return T_ARRAY(parseAnnotation(s.slice(0, -2)))
+
+  // Tuple: [String, Int, Bool]
+  if s.startsWith("[") and s.endsWith("]"):
+    val inner = s.slice(1, -1)
+    if not inner.trim(): return T_TUPLE([])
+    val parts = splitAtTopLevel(inner, ", ")
+    return T_TUPLE(parts.map(p -> parseAnnotation(p.replace(/^\.\.\./, "").trim())))
+
+  // Inline object type: { key: Type, key2?: Type }
+  if s.startsWith("{") and s.endsWith("}"):
+    val inner = s.slice(1, -1).trim()
+    val shape = new Map()
+    if inner:
+      val pairs = splitAtTopLevel(inner, ", ")
+      for pair in pairs:
+        val idxMatch = pair.match(/^\[(\w+):\s*\w+\]:\s*(.+)$/)
+        if idxMatch:
+          shape.set("[index]", parseAnnotation(idxMatch[2]))
+          continue
+        val colonIdx = pair.indexOf(":")
+        if colonIdx >= 0:
+          val rawKey  = pair.slice(0, colonIdx).trim().replace(/^readonly\s+/, "")
+          val key     = rawKey.replace(/\?$/, "")
+          val opt     = rawKey.endsWith("?")
+          val valType = parseAnnotation(pair.slice(colonIdx + 1).trim())
+          shape.set(key, opt ? T_UNION(valType, T_VOID) : valType)
+    return T_OBJECT(shape)
+
+  // Generic / Utility types: Array<T>, Record<K,V>, Partial<T> etc.
+  val genMatch = s.match(/^(\w+)<(.+)>$/s)
+  if genMatch:
+    val gname    = genMatch[1]
+    val rawArgs  = splitAtTopLevel(genMatch[2], ", ")
+    val args     = rawArgs.map(a -> parseAnnotation(a.trim()))
+    if gname == "Array" or gname == "List" or gname == "ReadonlyArray":
+      return T_ARRAY(args[0] ?? T_UNKNOWN)
+    if gname == "NonNullable":
+      return resolveNonNullable(args[0])
+    if gname == "Partial":   return { kind: "utility", util: "Partial",   inner: args[0] }
+    if gname == "Required":  return { kind: "utility", util: "Required",  inner: args[0] }
+    if gname == "Readonly":  return args[0]
+    if gname == "Record":    return T_RECORD(args[0] ?? T_STRING, args[1] ?? T_UNKNOWN)
+    if gname == "Pick":      return { kind: "utility", util: "Pick",   inner: args[0], keys: args[1] }
+    if gname == "Omit":      return { kind: "utility", util: "Omit",   inner: args[0], keys: args[1] }
+    if gname == "Exclude":   return { kind: "utility", util: "Exclude", inner: args[0], keys: args[1] }
+    if gname == "Extract":   return { kind: "utility", util: "Extract", inner: args[0], keys: args[1] }
+    if gname == "ReturnType":return { kind: "utility", util: "ReturnType", inner: args[0] }
+    if gname == "Parameters":return { kind: "utility", util: "Parameters", inner: args[0] }
+    if gname == "Awaited":   return { kind: "utility", util: "Awaited",  inner: args[0] }
+    return { kind: "generic", name: gname, args }
+
+  // Primitive or named
+  if PRIMITIVE_MAP[s]: return PRIMITIVE_MAP[s]
+  return T_NAMED(s)
+
+fn resolveNonNullable(t):
+  if not t: return T_UNKNOWN
+  if t.kind == "union":
+    return T_UNION(...t.members.filter(m -> m.kind != "null" and m.kind != "void"))
+  if t.kind == "null" or t.kind == "void": return T_NEVER
+  return t
+
+// ── Basic assignability ───────────────────────────────────────────────────────
+fn basicAssignable(from_, to_):
+  if not from_ or not 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"  and to_.kind == "void":  return true
+  if from_.kind == "null"  and to_.kind == "null":  return true
+
+  // Null assignable to nullable union
+  if from_.kind == "null" and to_.kind == "union":
+    return to_.members.some(m -> m.kind == "null" or m.kind == "any" or 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
+  if to_.kind == "union":
+    return to_.members.some(m -> basicAssignable(from_, m))
+
+  // Intersection
+  if from_.kind == "intersection":
+    return from_.members.some(m -> basicAssignable(m, to_))
+  if to_.kind == "intersection":
+    return to_.members.every(m -> basicAssignable(from_, m))
+
+  // Primitives
+  if from_.kind == "primitive" and to_.kind == "primitive":
+    if from_.name == to_.name: return true
+    if to_.name == "Number" and (from_.name == "Int" or from_.name == "Float" or from_.name == "Number"): return true
+    if to_.name == "Float"  and from_.name == "Int": return true
+    if from_.name == "Bool" and to_.name == "Boolean": return true
+    if from_.name == "Boolean" and to_.name == "Bool": return true
+    return false
+
+  // Literal to primitive
+  if from_.kind == "literal" and to_.kind == "primitive":
+    val lmap = { string: "String", number: "Number", boolean: "Bool" }
+    return lmap[from_.prim] == to_.name or (from_.prim == "number" and (to_.name == "Int" or to_.name == "Float" or to_.name == "Number"))
+
+  // Named types
+  if from_.kind == "named" and to_.kind == "named":
+    return from_.name == to_.name or to_.name == "Object"
+
+  // Generic types (covariant args)
+  if from_.kind == "generic" and to_.kind == "generic":
+    val arrayNames = new Set(["Array", "List", "ReadonlyArray"])
+    if from_.name != to_.name:
+      if not (arrayNames.has(from_.name) and 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" and to_.kind == "tuple":
+    if from_.types.length != to_.types.length: return false
+    return from_.types.every((t, i) -> basicAssignable(t, to_.types[i]))
+  // Array to tuple
+  if from_.kind == "generic" and from_.name == "Array" and to_.kind == "tuple":
+    val elemType = from_.args[0] ?? T_UNKNOWN
+    if elemType.kind == "unknown": return true
+    return to_.types.every(t -> basicAssignable(elemType, t))
+
+  // Object structural
+  if from_.kind == "object" and to_.kind == "object":
+    for pair in to_.shape.entries():
+      val key    = pair[0]
+      val toType = pair[1]
+      if not from_.shape.has(key): return false
+      if not basicAssignable(from_.shape.get(key), toType): return false
+    return true
+
+  // Object to named (structural checked in class)
+  if from_.kind == "object" and to_.kind == "named": return true
+
+  // Function type
+  if from_.kind == "fn" and to_.kind == "fn":
+    if to_.ret and from_.ret: return basicAssignable(from_.ret, to_.ret)
+    return true
+
+  // Record
+  if from_.kind == "record" and to_.kind == "record":
+    return basicAssignable(from_.val, to_.val)
+
+  // Utility types
+  if to_.kind == "utility":   return true
+  if from_.kind == "utility": return true
+
+  return false
+
+// ── Type merging ──────────────────────────────────────────────────────────────
+fn mergeTypes(a, b):
+  if not a or a.kind == "unknown": return b ?? T_UNKNOWN
+  if not b or b.kind == "unknown": return a
+  if typeStr(a) == typeStr(b): return a
+  if a.kind == "any" or b.kind == "any": return T_ANY
+  return T_UNION(a, b)
+
+// ── Type Environment ──────────────────────────────────────────────────────────
+export class TypeEnv:
+  parent: any
+  vars: any
+  retType: any
+  isAsync: bool
+
+  fn set(name, type_):
+    self.vars.set(name, type_)
+
+  fn has(name):
+    var e = self
+    while e:
+      if e.vars.has(name): return true
+      e = e.parent
+    return false
+
+  fn get(name):
+    var env = self
+    while env:
+      if env.vars.has(name): return env.vars.get(name)
+      env = env.parent
+    return null
+
+  fn child():
+    return new TypeEnv(self, new Map(), self.retType, self.isAsync)
+
+  fn childFn(retType, isAsync_):
+    return new TypeEnv(self, new Map(), retType, isAsync_ ?? false)
+
+  fn narrow(name, type_):
+    val c = new TypeEnv(self, new Map(), self.retType, self.isAsync)
+    if name and type_: c.vars.set(name, type_)
+    return c
+
+// ── Type Check Error ──────────────────────────────────────────────────────────
+class TypeCheckError:
+  message: any
+  name: any
+  hint: any
+  line: any
+  col: any
+
+// ── Main Type Checker ─────────────────────────────────────────────────────────
+export class FluxTypeChecker:
+  errors: any[]
+  warnings: any[]
+  interfaces: any
+  types: any
+  classes: any
+  enums: any
+
+  fn _err(msg, loc, hint):
+    val e = new TypeCheckError()
+    e.message = msg
+    e.name    = "TypeError"
+    e.hint    = hint ?? null
+    if loc:
+      e.line = loc.line
+      e.col  = loc.col
+    self.errors.push(e)
+
+  fn _warn(msg, loc, hint):
+    val w = new TypeCheckError()
+    w.message = msg
+    w.name    = "TypeError"
+    w.hint    = hint ?? null
+    if loc:
+      w.line = loc.line
+      w.col  = loc.col
+    self.warnings.push(w)
+
+  fn check(ast):
+    self.errors     = []
+    self.warnings   = []
+    self.interfaces = new Map()
+    self.types      = new Map()
+    self.classes    = new Map()
+    self.enums      = new Map()
+
+    self._collectDeclarations(ast.body)
+    self._validateImplementations()
+
+    val env = new TypeEnv(null, new Map(), null, false)
+    self._registerBuiltins(env)
+    self._checkStmts(ast.body, env)
+
+    return { errors: self.errors, warnings: self.warnings }
+
+  fn _collectDeclarations(stmts):
+    for node in stmts:
+      val n = node.type == "ExportDecl" ? node.decl : node
+      if not n: continue
+      if n.type == "InterfaceDecl": self.interfaces.set(n.name, n)
+      else if n.type == "TypeDecl":  self.types.set(n.name, n)
+      else if n.type == "ClassDecl": self.classes.set(n.name, n)
+      else if n.type == "EnumDecl":  self.enums.set(n.name, n)
+
+  fn _validateImplementations():
+    for clsPair in self.classes.entries():
+      val cls = clsPair[1]
+      for ifaceName in (cls.interfaces ?? []):
+        self._checkInterfaceImpl(cls, ifaceName)
+
+  fn _checkInterfaceImpl(cls, ifaceName):
+    val iface = self.interfaces.get(ifaceName)
+    if not iface:
+      self._warn(
+        "Class '" + cls.name + "' implements unknown interface '" + ifaceName + "'",
+        cls.loc,
+        "Define 'interface " + ifaceName + "' before use"
+      )
+      return
+    for member in iface.members:
+      if member.kind == "method":
+        val impl = cls.methods.find(m -> m.name == member.name)
+        if not impl:
+          self._err(
+            "Class '" + cls.name + "' does not implement method '" + member.name + "()' required by '" + ifaceName + "'",
+            cls.loc,
+            "Add 'fn " + member.name + "(...)' to the class"
+          )
+      else if member.kind == "field" and not member.optional:
+        val hasField  = cls.fields.find(f -> f.name == member.name)
+        val hasMethod = cls.methods.find(m -> m.name == member.name)
+        if not hasField and not hasMethod:
+          self._err(
+            "Class '" + cls.name + "' is missing field '" + member.name + "' required by '" + ifaceName + "'",
+            cls.loc,
+            "Add '" + member.name + ": " + (member.typeAnn ?? "Any") + "' to the class"
+          )
+    for superIface in (iface.superInterfaces ?? []):
+      self._checkInterfaceImpl(cls, superIface)
+
+  fn _isStructurallyCompatible(objShape, typeName):
+    val iface = self.interfaces.get(typeName)
+    if not iface:
+      val cls = self.classes.get(typeName)
+      if not cls: return false
+      for field in cls.fields:
+        if not objShape.has(field.name) and not field.optional: return false
+      return true
+    for member in iface.members:
+      if member.kind == "field" and not member.optional:
+        if not objShape.has(member.name): return false
+    return true
+
+  fn _isAssignable(from_, to_):
+    if not from_ or not 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
+
+    // Structural: object literal vs interface/class
+    if from_.kind == "object" and to_.kind == "named":
+      return self._isStructurallyCompatible(from_.shape, to_.name)
+
+    // Named satisfies interface (structural check)
+    if from_.kind == "named" and to_.kind == "named":
+      if from_.name == to_.name: return true
+      if to_.name == "Object": return true
+      val cls = self.classes.get(from_.name)
+      if cls and (cls.interfaces ?? []).includes(to_.name): return true
+      if cls and cls.superClass == to_.name: return true
+      val iface = self.interfaces.get(from_.name)
+      if iface and (iface.superInterfaces ?? []).includes(to_.name): return true
+      return false
+
+    // Utility types
+    if to_.kind == "utility":
+      if to_.util == "Partial":    return true
+      if to_.util == "Required":   return self._isAssignable(from_, to_.inner)
+      if to_.util == "NonNullable":return from_.kind != "null" and from_.kind != "void"
+      return true
+    if from_.kind == "utility": return true
+
+    return basicAssignable(from_, to_)
+
+  fn _analyzeNarrowingCondition(condExpr, env):
+    if not condExpr: return null
+
+    // x != null / x !== null
+    if condExpr.type == "BinaryExpr" and (condExpr.op == "!=" or condExpr.op == "!==") and condExpr.left.type == "Identifier" and condExpr.right.type == "NullLit":
+      val name  = condExpr.left.name
+      val t     = env.get(name)
+      if t and t.kind == "union":
+        val narrowed = T_UNION(...t.members.filter(m -> m.kind != "null" and m.kind != "void"))
+        return { varName: name, trueType: narrowed, falseType: T_UNION(T_NULL, T_VOID) }
+
+    // typeof x === "string"
+    if condExpr.type == "BinaryExpr" and (condExpr.op == "===" or condExpr.op == "==") and condExpr.left.type == "TypeofExpr" and condExpr.left.operand.type == "Identifier" and condExpr.right.type == "StringLit":
+      val name = condExpr.left.operand.name
+      val typeMap = { string: T_STRING, number: T_NUMBER, boolean: T_BOOL, undefined: T_VOID }
+      val narrowedTrue = typeMap[condExpr.right.value] ?? T_UNKNOWN
+      return { varName: name, trueType: narrowedTrue, falseType: env.get(name) ?? T_UNKNOWN }
+
+    // x instanceof Class
+    if condExpr.type == "BinaryExpr" and condExpr.op == "instanceof" and condExpr.left.type == "Identifier":
+      val name = condExpr.left.name
+      val 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 narrowing: x (truthy)
+    if condExpr.type == "Identifier":
+      val name = condExpr.name
+      val t    = env.get(name)
+      if t and t.kind == "union":
+        val narrowed = T_UNION(...t.members.filter(m -> m.kind != "null" and m.kind != "void"))
+        return { varName: name, trueType: narrowed, falseType: T_UNION(T_NULL, T_VOID) }
+
+    return null
+
+  fn _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("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"))
+    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"))
+
+  fn _inferType(node, env):
+    if not node: return T_UNKNOWN
+    if node.type == "NumberLit":
+      if String(node.value).includes("."): return T_FLOAT
+      return T_INT
+    if node.type == "StringLit": return T_STRING
+    if node.type == "BoolLit":   return T_BOOL
+    if node.type == "NullLit":   return T_NULL
+    if node.type == "Identifier":
+      val t = env.get(node.name)
+      return t ?? T_UNKNOWN
+    if node.type == "ArrayExpr":
+      if node.items.length == 0: return T_ARRAY(T_UNKNOWN)
+      val elemTypes = node.items.map(i -> i ? self._inferType(i, env) : T_UNKNOWN)
+      val merged = elemTypes.reduce((a, b) -> mergeTypes(a, b), T_UNKNOWN)
+      return T_ARRAY(merged)
+    if node.type == "ObjectExpr":
+      val shape = new Map()
+      for pair in node.pairs:
+        if not pair.spread and pair.key:
+          shape.set(pair.key, pair.value ? self._inferType(pair.value, env) : T_UNKNOWN)
+      return T_OBJECT(shape)
+    if node.type == "LambdaExpr":
+      val paramTypes = node.params.map(p -> p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN)
+      val retType    = node.retType ? parseAnnotation(node.retType) : T_UNKNOWN
+      return T_FN(paramTypes, retType)
+    if node.type == "CallExpr" or node.type == "OptCallExpr":
+      val calleeType = self._inferType(node.callee, env)
+      if calleeType.kind == "fn": return calleeType.ret ?? T_UNKNOWN
+      return T_UNKNOWN
+    if node.type == "MemberExpr" or node.type == "OptMemberExpr":
+      return T_UNKNOWN
+    if node.type == "TernaryExpr":
+      val thenType = self._inferType(node.then, env)
+      val elseType = self._inferType(node.else_, env)
+      return mergeTypes(thenType, elseType)
+    if node.type == "BinaryExpr":
+      if node.op == "+" or node.op == "-" or node.op == "*" or node.op == "/" or node.op == "%":
+        return T_NUMBER
+      if node.op == "==" or node.op == "!=" or node.op == "===" or node.op == "!==" or node.op == "<" or node.op == ">" or node.op == "<=" or node.op == ">=":
+        return T_BOOL
+      if node.op == "and" or node.op == "or" or node.op == "&&" or node.op == "||":
+        return T_BOOL
+      return T_UNKNOWN
+    if node.type == "AwaitExpr":
+      val inner = self._inferType(node.operand, env)
+      return inner
+    if node.type == "NewExpr":
+      if node.callee and node.callee.type == "Identifier":
+        return T_NAMED(node.callee.name)
+      return T_UNKNOWN
+    if node.type == "TemplateLit": return T_STRING
+    if node.type == "CastExpr" or node.type == "AsConstExpr":
+      if node.typeAnn: return parseAnnotation(node.typeAnn)
+      return self._inferType(node.expr, env)
+    return T_UNKNOWN
+
+  fn _checkStmts(stmts, env):
+    for node in stmts: self._checkStmt(node, env)
+
+  fn _checkStmt(node, env):
+    if not node: return
+
+    if node.type == "VarDecl":
+      val declared = node.typeAnn ? parseAnnotation(node.typeAnn) : null
+      var actual = null
+      if node.init: actual = self._inferType(node.init, env)
+      if declared and actual and actual.kind != "unknown":
+        if not self._isAssignable(actual, declared):
+          self._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)
+
+    else if node.type == "DestructureDecl":
+      val srcType = node.init ? self._inferType(node.init, env) : T_UNKNOWN
+      if node.patternType == "object":
+        for p in node.pattern:
+          var memberType = T_UNKNOWN
+          if srcType.kind == "object" and srcType.shape.has(p.key):
+            memberType = srcType.shape.get(p.key)
+          env.set(p.alias, memberType)
+      else:
+        var idx = 0
+        for p in node.pattern:
+          if p:
+            var elemType = T_UNKNOWN
+            if srcType.kind == "tuple" and srcType.types[idx]:
+              elemType = srcType.types[idx]
+            else if srcType.kind == "generic" and srcType.name == "Array":
+              elemType = srcType.args[0] ?? T_UNKNOWN
+            env.set(p.name, elemType)
+          idx = idx + 1
+
+    else if node.type == "FnDecl":
+      val retType    = node.retType ? parseAnnotation(node.retType) : null
+      val 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))
+      val fnEnv = env.childFn(retType, node.async)
+      var i = 0
+      for p in node.params:
+        fnEnv.set(p.name, paramTypes[i])
+        i = i + 1
+      if node.inline:
+        val bodyType = self._inferType(node.body, fnEnv)
+        if retType and bodyType and bodyType.kind != "unknown":
+          if not self._isAssignable(bodyType, retType):
+            self._err(
+              "Function '" + (node.name ?? "(anon)") + "' returns '" + typeStr(bodyType) + "' but declared '" + typeStr(retType) + "'",
+              node.loc,
+              "Fix return type or update the annotation"
+            )
+      else:
+        self._checkStmts(node.body, fnEnv)
+
+    else if node.type == "ClassDecl":
+      env.set(node.name, T_NAMED(node.name))
+      val clsEnv = env.child()
+      val shape  = new Map()
+      for f in node.fields:
+        val 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 m in node.methods: self._checkStmt(m, clsEnv)
+
+    else if node.type == "TypeDecl":
+      for v in 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(f_ -> T_ANY), T_NAMED(node.name)))
+
+    else if node.type == "InterfaceDecl":
+      env.set(node.name, T_NAMED(node.name))
+
+    else if node.type == "EnumDecl":
+      env.set(node.name, T_NAMED(node.name))
+
+    else if node.type == "IfStmt":
+      self._inferType(node.cond, env)
+      val narrowing = self._analyzeNarrowingCondition(node.cond, env)
+      val thenEnv = narrowing ? env.narrow(narrowing.varName, narrowing.trueType) : env.child()
+      val elseEnv = narrowing ? env.narrow(narrowing.varName, narrowing.falseType) : env.child()
+      self._checkStmts(node.then, thenEnv)
+      for ei in node.elseifs:
+        self._inferType(ei.cond, env)
+        self._checkStmts(ei.body, env.child())
+      if node.else_: self._checkStmts(node.else_, elseEnv)
+
+    else if node.type == "ForInStmt":
+      val iterType = self._inferType(node.iter, env)
+      val inner    = env.child()
+      if iterType.kind == "generic" and iterType.name == "Array":
+        inner.set(node.var, iterType.args[0] ?? T_UNKNOWN)
+      else if iterType.kind == "tuple":
+        inner.set(node.var, iterType.types[0] ?? T_UNKNOWN)
+      else:
+        inner.set(node.var, T_UNKNOWN)
+      self._checkStmts(node.body, inner)
+
+    else if node.type == "WhileStmt" or node.type == "DoWhileStmt":
+      self._inferType(node.cond, env)
+      self._checkStmts(node.body ?? [], env.child())
+
+    else if node.type == "MatchStmt":
+      self._inferType(node.subject, env)
+      for arm in node.arms:
+        val inner = env.child()
+        if arm.pattern.type == "VariantPat":
+          for b in arm.pattern.bindings: inner.set(b, T_UNKNOWN)
+        self._checkStmts(arm.body, inner)
+
+    else if node.type == "ReturnStmt":
+      if node.value:
+        val retType  = env.retType
+        val retActual = self._inferType(node.value, env)
+        if retType and retActual and retActual.kind != "unknown":
+          if not self._isAssignable(retActual, retType):
+            self._err(
+              "Return type '" + typeStr(retActual) + "' is not assignable to declared '" + typeStr(retType) + "'",
+              node.loc,
+              "Fix the return value or update the return type annotation"
+            )
+
+    else if node.type == "TryCatchStmt":
+      self._checkStmts(node.tryBody, env.child())
+      if node.catchBody:
+        val inner = env.child()
+        if node.catchParam: inner.set(node.catchParam, T_ANY)
+        self._checkStmts(node.catchBody, inner)
+      if node.finallyBody: self._checkStmts(node.finallyBody, env.child())
+
+    else if node.type == "ThrowStmt":
+      if node.value: self._inferType(node.value, env)
+
+    else if node.type == "ImportDecl":
+      if node.defaultName: env.set(node.defaultName, T_ANY)
+      if node.namespaceName: env.set(node.namespaceName, T_ANY)
+      for n in node.names:
+        val nm = typeof n == "string" ? n : n.alias
+        env.set(nm, T_ANY)
+
+    else if node.type == "ExportDecl":
+      if node.isDefault:
+        self._inferType(node.decl, env)
+      else:
+        self._checkStmt(node.decl, env)
+
+    else if node.type == "ExprStmt":
+      self._inferType(node.expr, env)