@algosail/lang 0.2.11 → 0.5.0

package/lib/typecheck/adt-autogen-sigs.js

@@ -0,0 +1,345 @@
+/**
+ * L3 этап 8: сигнатуры автоген-слов ADT (RFC-0.1 §7, RFC-typecheck §5.8).
+ */
+import { lowerFirst } from '../names/lower-first.js'
+import {
+  modulePathForAstNode,
+  PRIMITIVE_TYPE_NAMES
+} from './normalize-sig.js'
+import { shareTvarsInSignature } from './unify-type.js'
+
+/** @returns {{ kind: 'tvar', name: string, source: null, decl: null }} */
+function tv (name) {
+  return { kind: 'tvar', name, source: null, decl: null }
+}
+
+/** @returns {{ kind: 'prim', name: string, source: null, decl: null }} */
+function prim (name) {
+  return { kind: 'prim', name, source: null, decl: null }
+}
+
+/** @returns {{ kind: 'stack_label', name: string, source: null }} */
+function sl (name) {
+  return { kind: 'stack_label', name, source: null }
+}
+
+/**
+ * @param {import('./normalize-sig.js').NormalizedSignature} inner
+ */
+function q (inner) {
+  return { kind: 'quote', source: null, inner }
+}
+
+/**
+ * @param {object[]} left
+ * @param {object[]} right
+ * @param {object} [meta]
+ * @returns {import('./normalize-sig.js').NormalizedSignature}
+ */
+function normSig (left, right, meta = {}) {
+  return {
+    left,
+    right,
+    effectsAdd: [],
+    effectsRemove: [],
+    ...meta
+  }
+}
+
+/**
+ * shareTvarsInSignature даёт каждой вложенной quotation новую область stack_label,
+ * из-за чего общий ~b веток eliminator-а (RFC-typecheck §5.8) распадается на разные узлы.
+ * После share выравниваем правый stack_label всех веточных Quote на один объект.
+ *
+ * @param {import('./normalize-sig.js').NormalizedSignature} sig
+ */
+function mergeSumEliminatorBranchOutputLabels (sig) {
+  if (sig.adtEliminator !== 'sum' || !sig.left || sig.left.length < 2) return
+  const quotes = sig.left.slice(1)
+  if (quotes.length < 2) return
+  const first = quotes[0]
+  if (first.kind !== 'quote' || !first.inner?.right?.length) return
+  const canon = first.inner.right[0]
+  if (!canon || canon.kind !== 'stack_label') return
+  for (let i = 1; i < quotes.length; i++) {
+    const qn = quotes[i]
+    if (qn.kind !== 'quote' || !qn.inner?.right?.length) continue
+    qn.inner.right[0] = canon
+  }
+}
+
+/**
+ * @param {string} modulePath
+ * @param {object} node
+ */
+function declRef (modulePath, node) {
+  return { path: modulePath, node }
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @param {object} expr
+ * @param {Map<string, object>} tvarByParam
+ * @returns {object | null}
+ */
+function payloadTypeToIr (env, modulePath, expr, tvarByParam) {
+  if (!expr) return null
+  const scopeInfo = env.scopeByPath.get(modulePath)
+  const typeIndex = scopeInfo?.typeIndex ?? new Map()
+  switch (expr.kind) {
+    case 'type_var': {
+      const t = tvarByParam.get(expr.name)
+      if (t) return t
+      return tv(expr.name)
+    }
+    case 'type_name': {
+      const nm = expr.name
+      if (PRIMITIVE_TYPE_NAMES.has(nm)) return prim(nm)
+      const def = typeIndex.get(nm)
+      if (def && (def.kind === 'sum_type' || def.kind === 'product_type')) {
+        const defPath =
+          modulePathForAstNode(env.snapshots, def) ?? modulePath
+        return {
+          kind: 'adt',
+          path: defPath,
+          type: nm,
+          source: null,
+          decl: declRef(defPath, def)
+        }
+      }
+      return { kind: 'opaque', name: nm, source: null, decl: null }
+    }
+    case 'paren_type':
+      return payloadTypeToIr(env, modulePath, expr.inner, tvarByParam)
+    case 'type_app': {
+      const ctor = expr.ctor
+      const args = []
+      for (const a of expr.args) {
+        const na = payloadTypeToIr(env, modulePath, a, tvarByParam)
+        if (!na) return null
+        args.push(na)
+      }
+      if (['List', 'Dict', 'Map'].includes(ctor)) {
+        return {
+          kind: 'app',
+          ctor,
+          args,
+          source: null,
+          decl: null
+        }
+      }
+      const def = typeIndex.get(ctor)
+      if (def && (def.kind === 'sum_type' || def.kind === 'product_type')) {
+        const defPath =
+          modulePathForAstNode(env.snapshots, def) ?? modulePath
+        return {
+          kind: 'app',
+          ctor,
+          args,
+          source: null,
+          decl: declRef(defPath, def)
+        }
+      }
+      return null
+    }
+    default:
+      return null
+  }
+}
+
+/**
+ * @param {object} sumAst
+ * @param {string} modulePath
+ * @param {Map<string, object>} tvarByParam
+ */
+function sumTypeIr (sumAst, modulePath, tvarByParam) {
+  const names = sumAst.typeParams ?? []
+  const ref = declRef(modulePath, sumAst)
+  if (names.length === 0) {
+    return {
+      kind: 'adt',
+      path: modulePath,
+      type: sumAst.name,
+      source: null,
+      decl: ref
+    }
+  }
+  const args = names.map((p) => tvarByParam.get(p))
+  return {
+    kind: 'app',
+    ctor: sumAst.name,
+    args,
+    source: null,
+    decl: ref
+  }
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {object} sumAst
+ * @param {string} modulePath
+ * @returns {Map<string, import('./normalize-sig.js').NormalizedSignature>}
+ */
+function signaturesForSum (env, sumAst, modulePath) {
+  /** @type {Map<string, import('./normalize-sig.js').NormalizedSignature>} */
+  const m = new Map()
+  const tvarByParam = new Map()
+  for (const p of sumAst.typeParams ?? []) {
+    tvarByParam.set(p, tv(p))
+  }
+  const sumIr = sumTypeIr(sumAst, modulePath, tvarByParam)
+
+  for (const tag of sumAst.tags ?? []) {
+    const wn = lowerFirst(tag.name)
+    if (tag.payload) {
+      const pay = payloadTypeToIr(env, modulePath, tag.payload, tvarByParam)
+      if (!pay) continue
+      const s = normSig([pay], [sumIr])
+      m.set(wn, shareTvarsInSignature(s))
+    } else {
+      const s = normSig([], [sumIr])
+      m.set(wn, shareTvarsInSignature(s))
+    }
+  }
+
+  const elimName = lowerFirst(sumAst.name)
+  const sLab = sl('s')
+  const bLab = sl('b')
+  /** @type {object[]} */
+  const branchQuotes = []
+  for (const tag of sumAst.tags ?? []) {
+    /** @type {object[]} */
+    const leftIn = [sLab]
+    if (tag.payload) {
+      const pay = payloadTypeToIr(env, modulePath, tag.payload, tvarByParam)
+      if (!pay) {
+        return m
+      }
+      leftIn.push(pay)
+    }
+    branchQuotes.push(q(normSig(leftIn, [bLab])))
+  }
+  const elimSig = normSig([sumIr, ...branchQuotes], [], {
+    adtEliminator: 'sum'
+  })
+  const elimShared = shareTvarsInSignature(elimSig)
+  mergeSumEliminatorBranchOutputLabels(elimShared)
+  m.set(elimName, elimShared)
+
+  return m
+}
+
+/**
+ * @param {object} prodAst
+ * @param {string} modulePath
+ * @param {Map<string, object>} tvarByParam
+ */
+function productTypeIr (prodAst, modulePath, tvarByParam) {
+  const names = prodAst.typeParams ?? []
+  const ref = declRef(modulePath, prodAst)
+  if (names.length === 0) {
+    return {
+      kind: 'adt',
+      path: modulePath,
+      type: prodAst.name,
+      source: null,
+      decl: ref
+    }
+  }
+  const args = names.map((p) => tvarByParam.get(p))
+  return {
+    kind: 'app',
+    ctor: prodAst.name,
+    args,
+    source: null,
+    decl: ref
+  }
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {object} prodAst
+ * @param {string} modulePath
+ * @returns {Map<string, import('./normalize-sig.js').NormalizedSignature>}
+ */
+function signaturesForProduct (env, prodAst, modulePath) {
+  /** @type {Map<string, import('./normalize-sig.js').NormalizedSignature>} */
+  const m = new Map()
+  const tvarByParam = new Map()
+  for (const p of prodAst.typeParams ?? []) {
+    tvarByParam.set(p, tv(p))
+  }
+  const prodIr = productTypeIr(prodAst, modulePath, tvarByParam)
+
+  const ctorName = lowerFirst(prodAst.name)
+  /** @type {object[]} */
+  const fieldIrs = []
+  for (const f of prodAst.fields ?? []) {
+    const ft = payloadTypeToIr(env, modulePath, f.type, tvarByParam)
+    if (!ft) return m
+    fieldIrs.push(ft)
+  }
+  m.set(ctorName, shareTvarsInSignature(normSig(fieldIrs, [prodIr])))
+
+  for (const f of prodAst.fields ?? []) {
+    const ft = payloadTypeToIr(env, modulePath, f.type, tvarByParam)
+    if (!ft) return m
+    const getter = lowerFirst(f.name + prodAst.name)
+    m.set(getter, shareTvarsInSignature(normSig([prodIr], [ft])))
+  }
+
+  const withName = lowerFirst(`with${prodAst.name}`)
+  const sLab = sl('s')
+  const bLab = sl('b')
+  const qInner = normSig([sLab, ...fieldIrs], [bLab])
+  const elimSig = normSig([prodIr, q(qInner)], [], {
+    adtEliminator: 'product'
+  })
+  m.set(withName, shareTvarsInSignature(elimSig))
+
+  return m
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @returns {Map<string, import('./normalize-sig.js').NormalizedSignature>}
+ */
+export function buildAutogenSignaturesForModule (env, modulePath) {
+  /** @type {Map<string, import('./normalize-sig.js').NormalizedSignature>} */
+  const out = new Map()
+  const adtMap = env.adtByPath?.get(modulePath)
+  if (!adtMap) return out
+
+  for (const entry of adtMap.values()) {
+    const ast = entry.ast
+    if (entry.kind === 'sum') {
+      const part = signaturesForSum(env, ast, modulePath)
+      for (const [k, v] of part) out.set(k, v)
+    } else if (entry.kind === 'product') {
+      const part = signaturesForProduct(env, ast, modulePath)
+      for (const [k, v] of part) out.set(k, v)
+    }
+  }
+  return out
+}
+
+/**
+ * Не перезаписывает существующие `@word` в sigIrByPath.
+ *
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {Map<string, Map<string, import('./normalize-sig.js').NormalizedSignature>>} sigIrByPath
+ */
+export function mergeAdtAutogenIntoSigIrByPath (env, sigIrByPath) {
+  for (const p of env.modulePathsOrdered) {
+    const perPath = sigIrByPath.get(p)
+    if (!perPath) continue
+    const auto = buildAutogenSignaturesForModule(env, p)
+    for (const [name, sig] of auto) {
+      if (!perPath.has(name)) {
+        perPath.set(name, sig)
+      }
+    }
+  }
+}

package/lib/typecheck/build-type-env.js

@@ -0,0 +1,148 @@
+/**
+ * L3 этап 1: окружение из снимков L2 (RFC-typecheck-0.1 §5.1, RFC-0.1 §11).
+ *
+ * @typedef {object} TypecheckEnv
+ * @property {string} entryPath
+ * @property {string[]} modulePathsOrdered
+ * @property {Map<string, object>} snapshots
+ * @property {Map<string, Map<string, object>>} wordDeclByPath
+ * @property {Map<string, { importMap: Map<string, object>, unq: Set<string>, exportWords: Set<string>, exportTypes: Set<string>, typeIndex: Map<string, object> }>} scopeByPath
+ * @property {Map<string, Map<string, object>>} [adtByPath] этап 2: только **валидные** объявления `&` (частично при диагностиках на других `&`; RFC-typecheck §5.1)
+ * @property {Map<string, Map<string, object>>} [sigIrByPath] этап 3: IR сигнатур для слов **без** ошибок нормализации (частичная карта при `ok: false`); слоты включают `prim`, `opaque` (FFI §5.4), `adt`, `app`, …
+ * @property {Map<string, Map<string, { asyncDefinition: boolean, mayFail: boolean }>>} [definitionEffectsByPath] этап 7: RFC-IR §6 (объявление)
+ * @property {object[]} [callSiteEffectMarks] этап 7: calleeAsync / calleeMayFail по шагам (RFC-typecheck §3, RFC-IR §6)
+ * @property {Map<string, Map<string, object>>} [stackSnapshotsByPath] этап 9: запись слова — см. [stack-step-snapshots.js](stack-step-snapshots.js) (`steps`, `nestedByParentStep`); для успешного слова — полная цепь; при ошибке в теле — префикс и `pre` на шаге сбоя (RFC-typecheck §3); при ошибке выхода слова — полная цепь по шагам
+ */
+import path from 'node:path'
+import { buildScopeForSnapshot } from '../names/module-scope.js'
+import { resolveImportPath } from '../names/import-path.js'
+
+/**
+ * Явное `@word` в экспортируемом модуле (не autogen).
+ *
+ * @param {object} depSnapshot
+ * @param {string} name
+ * @returns {object | null}
+ */
+export function resolveExportedWord (depSnapshot, name) {
+  if (!depSnapshot?.ok) return null
+  for (const it of depSnapshot.items) {
+    if (it.kind === 'word' && it.name === name) return it
+  }
+  return null
+}
+
+/**
+ * Топологический порядок: зависимость раньше импортёра. Только `snap.ok === true`.
+ *
+ * @param {Map<string, object>} snapshots
+ * @param {(p: string) => string | null | undefined} readFile
+ * @param {((spec: string, fromPath: string) => string | null) | undefined} resolvePackage
+ * @returns {string[]}
+ */
+function topoSortOkModules (snapshots, readFile, resolvePackage) {
+  /** @type {string[]} */
+  const vertices = []
+  for (const [p, snap] of snapshots) {
+    if (snap?.ok === true) vertices.push(p)
+  }
+  vertices.sort()
+  const vertexSet = new Set(vertices)
+  /** @type {Map<string, number>} */
+  const indegree = new Map()
+  /** @type {Map<string, string[]>} */
+  const adj = new Map()
+  for (const p of vertices) {
+    indegree.set(p, 0)
+    adj.set(p, [])
+  }
+  for (const p of vertices) {
+    const snap = snapshots.get(p)
+    for (const item of snap.items) {
+      if (item.kind !== 'import') continue
+      const r = resolveImportPath(p, item.path, readFile, resolvePackage)
+      if (!r.resolvedPath || !vertexSet.has(r.resolvedPath)) continue
+      const dep = snapshots.get(r.resolvedPath)
+      if (!dep?.ok) continue
+      indegree.set(p, indegree.get(p) + 1)
+      adj.get(r.resolvedPath).push(p)
+    }
+  }
+  const visited = new Set()
+  /** @type {string[]} */
+  const out = []
+  while (visited.size < vertices.length) {
+    /** @type {string[]} */
+    const zeros = []
+    for (const v of vertices) {
+      if (!visited.has(v) && indegree.get(v) === 0) zeros.push(v)
+    }
+    if (zeros.length === 0) break
+    zeros.sort()
+    const u = zeros[0]
+    visited.add(u)
+    out.push(u)
+    for (const v of adj.get(u)) {
+      indegree.set(v, indegree.get(v) - 1)
+    }
+  }
+  if (out.length < vertices.length) {
+    const rest = vertices.filter((p) => !visited.has(p)).sort()
+    out.push(...rest)
+  }
+  return out
+}
+
+/**
+ * @param {{
+ *   snapshots: Map<string, object>,
+ *   entryPath: string,
+ *   readFile: (p: string) => string | null | undefined,
+ *   resolvePackage?: (spec: string, fromPath: string) => string | null
+ * }} ctx
+ * @returns {{
+ *   entryPath: string,
+ *   modulePathsOrdered: string[],
+ *   snapshots: Map<string, object>,
+ *   wordDeclByPath: Map<string, Map<string, object>>,
+ *   scopeByPath: Map<string, { importMap: Map<string, object>, unq: Set<string>, exportWords: Set<string>, exportTypes: Set<string>, typeIndex: Map<string, object> }>
+ * }}
+ */
+export function buildTypecheckEnv (ctx) {
+  const { snapshots, entryPath, readFile, resolvePackage } = ctx
+  const normEntry = path.normalize(entryPath)
+  const ctxScope = { readFile, resolvePackage, snapshots }
+
+  /** @type {Map<string, Map<string, object>>} */
+  const wordDeclByPath = new Map()
+  /** @type {Map<string, { importMap: Map<string, object>, unq: Set<string>, exportWords: Set<string>, exportTypes: Set<string>, typeIndex: Map<string, object> }>} */
+  const scopeByPath = new Map()
+
+  for (const [p, snap] of snapshots) {
+    if (!snap?.ok) continue
+    /** @type {Map<string, object>} */
+    const words = new Map()
+    for (const it of snap.items) {
+      if (it.kind === 'word') words.set(it.name, it)
+    }
+    wordDeclByPath.set(p, words)
+    const scope = buildScopeForSnapshot(snap, ctxScope)
+    scopeByPath.set(p, {
+      importMap: scope.importMap,
+      unq: scope.unq,
+      exportWords: snap.exportWords,
+      exportTypes: snap.exportTypes,
+      typeIndex: snap.typeIndex
+    })
+  }
+
+  const modulePathsOrdered = topoSortOkModules(snapshots, readFile, resolvePackage)
+
+  return {
+    entryPath: normEntry,
+    modulePathsOrdered,
+    snapshots,
+    wordDeclByPath,
+    scopeByPath
+  }
+}

package/lib/typecheck/builtin-signatures.js

@@ -0,0 +1,183 @@
+/**
+ * L3: IR сигнатуры встроенных слов (RFC-builtins-0.1 §4.1–4.5).
+ */
+import { BUILTIN_WORDS } from '../parse/builtins-set.js'
+
+/** @returns {{ kind: 'tvar', name: string, source: null, decl: null }} */
+function tv (name) {
+  return { kind: 'tvar', name, source: null, decl: null }
+}
+
+/** @returns {{ kind: 'stack_label', name: string, source: null }} */
+function sl (name) {
+  return { kind: 'stack_label', name, source: null }
+}
+
+/**
+ * @param {import('./normalize-sig.js').NormalizedSignature} inner
+ * @returns {{ kind: 'quote', source: null, inner }}
+ */
+function q (inner) {
+  return { kind: 'quote', source: null, inner }
+}
+
+/**
+ * @param {object[]} left
+ * @param {object[]} right
+ * @returns {import('./normalize-sig.js').NormalizedSignature}
+ */
+function sig (left, right) {
+  return { left, right, effectsAdd: [], effectsRemove: [] }
+}
+
+/** У каждой лексемы — свои объекты tvar (не делить между встроенными). */
+function buildStackOnlySignatures () {
+  return new Map([
+    (() => {
+      const a = tv('a')
+      return ['dup', sig([a], [a, a])]
+    })(),
+    (() => {
+      const a = tv('a')
+      return ['drop', sig([a], [])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      return ['swap', sig([a, b], [b, a])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      return ['over', sig([a, b], [a, b, a])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      return ['dup2', sig([a, b], [a, b, a, b])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      return ['drop2', sig([a, b], [])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      const c = tv('c')
+      return ['rot', sig([a, b, c], [b, c, a])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      const c = tv('c')
+      return ['reverse', sig([a, b, c], [c, a, b])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      return ['nip', sig([a, b], [b])]
+    })(),
+    (() => {
+      const a = tv('a')
+      const b = tv('b')
+      return ['tuck', sig([a, b], [b, a, b])]
+    })(),
+    (() => {
+      const x1 = tv('x1')
+      const x2 = tv('x2')
+      const y1 = tv('y1')
+      const y2 = tv('y2')
+      return ['swap2', sig([x1, x2, y1, y2], [y1, y2, x1, x2])]
+    })()
+  ])
+}
+
+/**
+ * §4.3–4.5: call, dip, keep, bi, tri, spread, both.
+ * Порядок в left / right: снизу стека → вершина (слева направо в массиве).
+ */
+function buildStage6Signatures () {
+  return new Map([
+    (() => {
+      const s = sl('s')
+      const t = sl('t')
+      const a = tv('a')
+      const inner = sig([s], [t])
+      return ['dip', sig([s, a, q(inner)], [t, a])]
+    })(),
+    (() => {
+      const s = sl('s')
+      const t = sl('t')
+      const a = tv('a')
+      const inner = sig([s, a], [t])
+      return ['keep', sig([s, a, q(inner)], [t, a])]
+    })(),
+    (() => {
+      const s = sl('s')
+      const a = tv('a')
+      const b = tv('b')
+      const c = tv('c')
+      const q1 = q(sig([a], [b]))
+      const q2 = q(sig([a], [c]))
+      return ['bi', sig([s, a, q1, q2], [s, b, c])]
+    })(),
+    (() => {
+      const s = sl('s')
+      const a = tv('a')
+      const b = tv('b')
+      const c = tv('c')
+      const d = tv('d')
+      const q1 = q(sig([a], [b]))
+      const q2 = q(sig([a], [c]))
+      const q3 = q(sig([a], [d]))
+      return ['tri', sig([s, a, q1, q2, q3], [s, b, c, d])]
+    })(),
+    (() => {
+      const s = sl('s')
+      const a = tv('a')
+      const b = tv('b')
+      const c = tv('c')
+      const d = tv('d')
+      const q1 = q(sig([a], [c]))
+      const q2 = q(sig([b], [d]))
+      return ['spread', sig([s, a, b, q1, q2], [s, c, d])]
+    })(),
+    (() => {
+      const s = sl('s')
+      const x = tv('x')
+      const y = tv('y')
+      const inner = sig([x], [y])
+      return ['both', sig([s, x, x, q(inner)], [s, y, y])]
+    })()
+  ])
+}
+
+const STACK_ONLY = buildStackOnlySignatures()
+const STAGE6 = buildStage6Signatures()
+
+const ALL_STACK = new Map([...STACK_ONLY, ...STAGE6])
+
+/**
+ * @param {string} name
+ * @returns {import('./normalize-sig.js').NormalizedSignature | null}
+ */
+export function getBuiltinStackSignature (name) {
+  return ALL_STACK.get(name) ?? null
+}
+
+/**
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function isBuiltinSupportedStage4 (name) {
+  return BUILTIN_WORDS.has(name) && STACK_ONLY.has(name)
+}
+
+/**
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function isBuiltinDeferredStage6 (name) {
+  return false
+}