@algosail/lang 0.2.12 → 0.5.1

package/lib/typecheck/effect-decl.js

@@ -0,0 +1,124 @@
+/**
+ * L3 этап 7: объявленные эффекты сигнатуры (RFC-0.1 §5.7, RFC-IR-0.1 §6).
+ */
+
+/**
+ * @typedef {{ plusAsync: boolean, minusAsync: boolean, plusFail: boolean, minusFail: boolean }} EffectFlags
+ */
+
+/**
+ * @param {import('./normalize-sig.js').NormalizedSignature | null | undefined} sig
+ * @returns {EffectFlags}
+ */
+export function declaredEffectFlags (sig) {
+  const f = {
+    plusAsync: false,
+    minusAsync: false,
+    plusFail: false,
+    minusFail: false
+  }
+  if (!sig) return f
+  for (const e of sig.effectsAdd ?? []) {
+    if (e.name === 'Async') f.plusAsync = true
+    if (e.name === 'Fail') f.plusFail = true
+  }
+  for (const e of sig.effectsRemove ?? []) {
+    if (e.name === 'Async') f.minusAsync = true
+    if (e.name === 'Fail') f.minusFail = true
+  }
+  return f
+}
+
+/**
+ * Контекст (слово или quotation inner) может содержать вызов callee, у которого всплывает +Async/+Fail к нему.
+ * Разрешено при +Name или при исходящем -Name (обёртка, §5.7).
+ *
+ * @param {EffectFlags} ctx
+ */
+export function contextAllowsAsyncCallFromCallee (ctx) {
+  return ctx.plusAsync || ctx.minusAsync
+}
+
+/**
+ * @param {EffectFlags} ctx
+ */
+export function contextAllowsFailCallFromCallee (ctx) {
+  return ctx.plusFail || ctx.minusFail
+}
+
+/**
+ * Вызов callee обязывает непосредственного вызывающего учитывать +Async (E1310), если у callee объявлен +Async
+ * и не снят исходящим -Async у callee (§5.7.1).
+ *
+ * @param {EffectFlags} callee
+ */
+export function calleeAsyncPropagatesToCaller (callee) {
+  return callee.plusAsync && !callee.minusAsync
+}
+
+/**
+ * @param {EffectFlags} callee
+ */
+export function calleeFailPropagatesToCaller (callee) {
+  return callee.plusFail && !callee.minusFail
+}
+
+/**
+ * @param {object | null} span
+ * @returns {{ effectsAdd: object[], effectsRemove: object[] }}
+ */
+export function effectArraysFromFlags (flags, span) {
+  const effectsAdd = []
+  const effectsRemove = []
+  const side = 'right'
+  if (flags.plusAsync) {
+    effectsAdd.push({
+      kind: 'sig_effect_add',
+      span: span ?? null,
+      name: 'Async',
+      side
+    })
+  }
+  if (flags.plusFail) {
+    effectsAdd.push({
+      kind: 'sig_effect_add',
+      span: span ?? null,
+      name: 'Fail',
+      side
+    })
+  }
+  if (flags.minusAsync) {
+    effectsRemove.push({
+      kind: 'sig_effect_remove',
+      span: span ?? null,
+      name: 'Async',
+      side
+    })
+  }
+  if (flags.minusFail) {
+    effectsRemove.push({
+      kind: 'sig_effect_remove',
+      span: span ?? null,
+      name: 'Fail',
+      side
+    })
+  }
+  return { effectsAdd, effectsRemove }
+}
+
+/**
+ * Сравнение маркеров исходящей части вложенной quotation_sig при унификации Quote (этап 7).
+ *
+ * @param {import('./normalize-sig.js').NormalizedSignature} ia
+ * @param {import('./normalize-sig.js').NormalizedSignature} ib
+ */
+export function quotationOutgoingEffectsEqual (ia, ib) {
+  const a = declaredEffectFlags(ia)
+  const b = declaredEffectFlags(ib)
+  return (
+    a.plusAsync === b.plusAsync &&
+    a.minusAsync === b.minusAsync &&
+    a.plusFail === b.plusFail &&
+    a.minusFail === b.minusFail
+  )
+}

package/lib/typecheck/index.js

@@ -0,0 +1,55 @@
+import { resolveSailNames } from '../names/resolve-sail.js'
+import { buildTypecheckEnv } from './build-type-env.js'
+import { validateAdtDeclarations } from './validate-adt.js'
+import { normalizeAllSignatures } from './normalize-sig.js'
+import { mergeAdtAutogenIntoSigIrByPath } from './adt-autogen-sigs.js'
+import { checkAllWordBodies } from './check-word-body.js'
+
+/**
+ * L3: типизация и проверка стека после успешного Parse и Name resolution (RFC-0.1 §11 п.1–2).
+ * Диагностики этой фазы — коды E13xx (RFC-0.1 §13). Алгоритм — RFC-typecheck-0.1.
+ *
+ * Вход совпадает с {@link resolveSailNames}: один обход графа модулей; при `ok === false`
+ * возвращаются диагностики L0/L1/L2 без запуска тела L3.
+ *
+ * **Порядок фаз `typecheckSail`** (имена шагов, не «этап N» в сообщениях об ошибках):
+ *
+ * | Шаг | Действие | Тесты (brittle) |
+ * |-----|----------|-----------------|
+ * | L2 + среда | `resolveSailNames` → `buildTypecheckEnv` | `typecheck-env.test.js`, `typecheck-pipeline.test.js` |
+ * | ADT | `validateAdtDeclarations` | `adt-decl-stage2.test.js` |
+ * | Сигнатуры | `normalizeAllSignatures` (+ автоген сигнатур ADT) | `sig-type-stage3.test.js` |
+ * | Тела слов | `checkAllWordBodies` (стек, унификация, эффекты) | `stack-check-stage4.test.js` … `stack-check-stage9.test.js` |
+ *
+ * При успехе L2 поле `env` — среда резолва и импортов. `env.adtByPath` — только **валидные** `&` (частично, если часть объявлений с ошибками; RFC-typecheck §5.1).
+ * `env.sigIrByPath` — **частичная** карта после нормализации + `mergeAdtAutogenIntoSigIrByPath` (автоген только для ADT из `adtByPath`).
+ * Итог: `ok === false`, если есть **хоть одна** диагностика ADT, сигнатур или тел; `diagnostics` — склейка **ADT → сигнатуры → тела** (полный отчёт, пайплайн не обрывается до проверки тел).
+ * `env.stackSnapshotsByPath` — успешные слова и **частичные** цепочки по RFC-typecheck §3 / RFC-IR §1.1 при ошибке в теле.
+ *
+ * **E1302** (некорректная сигнатура quotation, RFC-0.1 §13): код и шаблон `e1302QuotationSig` зарезервированы; эмиссия из
+ * нормализации сигнатур не подключена до уточнения RFC, какие сбои `quotation_sig` / `quotation_type` отличать от прочих E1304.
+ *
+ * @param {{ entryPath: string, readFile: (p: string) => string | null | undefined, resolvePackage?: (spec: string, fromPath: string) => string | null }} opts
+ * @returns {{ ok: boolean, diagnostics: object[], snapshots?: Map<string, object>, env?: object }}
+ */
+export function typecheckSail (opts) {
+  const r = resolveSailNames({ ...opts, withSnapshots: true })
+  if (!r.ok) {
+    return { ok: false, diagnostics: r.diagnostics }
+  }
+  const env = buildTypecheckEnv({
+    snapshots: r.snapshots,
+    entryPath: opts.entryPath,
+    readFile: opts.readFile,
+    resolvePackage: opts.resolvePackage
+  })
+  const { diagnostics: adtDiags, adtByPath } = validateAdtDeclarations(env)
+  env.adtByPath = adtByPath
+  const { diagnostics: sigDiags, sigIrByPath } = normalizeAllSignatures(env)
+  mergeAdtAutogenIntoSigIrByPath(env, sigIrByPath)
+  env.sigIrByPath = sigIrByPath
+  const bodyDiags = checkAllWordBodies(env)
+  const diagnostics = [...adtDiags, ...sigDiags, ...bodyDiags]
+  const ok = diagnostics.length === 0
+  return { ok, diagnostics, snapshots: r.snapshots, env }
+}

package/lib/typecheck/normalize-sig.js

@@ -0,0 +1,369 @@
+/**
+ * L3 этап 3: нормализация типовых выражений в сигнатурах (IR + source/decl).
+ */
+import * as diag from '../parse/diagnostics.js'
+
+/** @type {ReadonlySet<string>} */
+export const PRIMITIVE_TYPE_NAMES = new Set([
+  'Str',
+  'String',
+  'Num',
+  'Int',
+  'Bool',
+  'Float',
+  'Double',
+  'Char',
+  'Unit',
+  'Nil'
+])
+
+/** @type {ReadonlySet<string>} */
+const BUILTIN_TYPE_CTORS = new Set(['List', 'Dict', 'Map'])
+
+/**
+ * @param {object} span
+ * @param {string} code
+ * @param {string} message
+ */
+function pushDiag (out, span, code, message) {
+  const d = { code, message }
+  if (span?.start) {
+    d.offset = span.start.offset
+    d.line = span.start.line
+    d.column = span.start.column
+  }
+  out.push(d)
+}
+
+/**
+ * Модуль, в `items` которого лежит данный узел верхнего уровня (sum/product/word/import).
+ *
+ * @param {Map<string, object>} snapshots
+ * @param {object} node
+ * @returns {string | null}
+ */
+export function modulePathForAstNode (snapshots, node) {
+  for (const [p, snap] of snapshots) {
+    if (!snap?.ok) continue
+    for (const it of snap.items) {
+      if (it === node) return p
+    }
+  }
+  return null
+}
+
+/**
+ * @typedef {{ path: string, node: object }} TypeDeclRef
+ *
+ * @typedef {{ kind: 'prim', name: string, source: object, decl: null }} IrPrim
+ * @typedef {{ kind: 'tvar', name: string, source: object, decl?: TypeDeclRef | null }} IrTvar
+ * @typedef {{ kind: 'app', ctor: string, args: object[], source: object, decl: TypeDeclRef | null }} IrApp
+ * @typedef {{ kind: 'mod_adt', module: string, type: string, source: object, decl: TypeDeclRef }} IrModAdt
+ * @typedef {{ kind: 'adt', path: string, type: string, source: object, decl: TypeDeclRef }} IrAdt
+ * @typedef {{ kind: 'opaque', name: string, source: object, decl: null }} IrOpaque — номинальный opaque FFI (RFC-0.1 §5.4), без параметров.
+ * @typedef {{ kind: 'stack_label', name: string, source: object }} IrStackLabel
+ * @typedef {{ kind: 'quote', source: object, inner: NormalizedSignature }} IrQuote
+ * @typedef {{ kind: 'named_quote', prefix: string, source: object, inner: NormalizedSignature }} IrNamedQuote
+ *
+ * @typedef {{
+ *   left: object[],
+ *   right: object[],
+ *   effectsAdd: object[],
+ *   effectsRemove: object[]
+ * }} NormalizedSignature
+ */
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @param {{ importMap: Map<string, object>, typeIndex: Map<string, object> }} scopeInfo
+ */
+function makeCtx (env, modulePath, scopeInfo) {
+  return {
+    env,
+    modulePath,
+    scopeInfo,
+    /** @type {object[]} */
+    diagnostics: []
+  }
+}
+
+/**
+ * @param {object} expr
+ * @param {ReturnType<typeof makeCtx>} ctx
+ * @returns {object | null}
+ */
+export function normalizeTypeExpr (expr, ctx) {
+  if (!expr) return null
+  switch (expr.kind) {
+    case 'type_name': {
+      const nm = expr.name
+      if (PRIMITIVE_TYPE_NAMES.has(nm)) {
+        return { kind: 'prim', name: nm, source: expr, decl: null }
+      }
+      const def = ctx.scopeInfo.typeIndex.get(nm)
+      if (def && (def.kind === 'sum_type' || def.kind === 'product_type')) {
+        const npar = def.typeParams?.length ?? 0
+        if (npar > 0) {
+          pushDiag(
+            ctx.diagnostics,
+            expr.span,
+            'E1311',
+            diag.e1311ParameterizedTypeNeedsParens(nm)
+          )
+          return null
+        }
+        const defPath =
+          modulePathForAstNode(ctx.env.snapshots, def) ?? ctx.modulePath
+        return {
+          kind: 'adt',
+          path: defPath,
+          type: nm,
+          source: expr,
+          decl: { path: defPath, node: def }
+        }
+      }
+      return { kind: 'opaque', name: nm, source: expr, decl: null }
+    }
+    case 'type_var':
+      return { kind: 'tvar', name: expr.name, source: expr, decl: null }
+    case 'module_type_ref': {
+      const { module: mod, type: ty } = expr
+      const dep = ctx.scopeInfo.importMap.get(mod)
+      if (!dep?.ok) {
+        pushDiag(ctx.diagnostics, expr.span, 'E1203', diag.e1203ModuleNotFound(mod))
+        return null
+      }
+      if (!dep.exportTypes.has(ty)) {
+        pushDiag(
+          ctx.diagnostics,
+          expr.span,
+          'E1204',
+          diag.e1204MissingMember(mod, ty)
+        )
+        return null
+      }
+      const node = dep.typeIndex.get(ty)
+      if (!node) {
+        pushDiag(
+          ctx.diagnostics,
+          expr.span,
+          'E1204',
+          diag.e1204MissingMember(mod, ty)
+        )
+        return null
+      }
+      const npar = node.typeParams?.length ?? 0
+      if (
+        npar > 0 &&
+        (node.kind === 'sum_type' || node.kind === 'product_type')
+      ) {
+        pushDiag(
+          ctx.diagnostics,
+          expr.span,
+          'E1311',
+          diag.e1311ParameterizedTypeNeedsParens(ty)
+        )
+        return null
+      }
+      const declPath = dep.path
+      return {
+        kind: 'mod_adt',
+        module: mod,
+        type: ty,
+        source: expr,
+        decl: { path: declPath, node }
+      }
+    }
+    case 'paren_type':
+      return normalizeTypeExpr(expr.inner, ctx)
+    case 'quotation_type': {
+      const inner = normalizeSignature(expr.inner, ctx)
+      if (!inner) return null
+      return { kind: 'quote', source: expr, inner }
+    }
+    case 'type_app': {
+      const ctor = expr.ctor
+      const args = []
+      for (const a of expr.args) {
+        const na = normalizeTypeExpr(a, ctx)
+        if (!na) return null
+        args.push(na)
+      }
+      if (BUILTIN_TYPE_CTORS.has(ctor)) {
+        return { kind: 'app', ctor, args, source: expr, decl: null }
+      }
+      const def = ctx.scopeInfo.typeIndex.get(ctor)
+      if (def && (def.kind === 'sum_type' || def.kind === 'product_type')) {
+        const defPath =
+          modulePathForAstNode(ctx.env.snapshots, def) ?? ctx.modulePath
+        return {
+          kind: 'app',
+          ctor,
+          args,
+          source: expr,
+          decl: { path: defPath, node: def }
+        }
+      }
+      pushDiag(
+        ctx.diagnostics,
+        expr.span,
+        'E1304',
+        diag.e1304UnknownTypeInSignature(ctor)
+      )
+      return null
+    }
+    default:
+      pushDiag(
+        ctx.diagnostics,
+        expr.span,
+        'E1304',
+        diag.e1304TypeMismatch('известное типовое выражение', expr.kind)
+      )
+      return null
+  }
+}
+
+/**
+ * @param {object} sig
+ * @param {ReturnType<typeof makeCtx>} ctx
+ * @returns {NormalizedSignature | null}
+ */
+export function normalizeSignature (sig, ctx) {
+  /** @type {object[]} */
+  const left = []
+  for (const item of sig.left) {
+    const s = normalizeSigItem(item, ctx)
+    if (!s) return null
+    left.push(s)
+  }
+  /** @type {object[]} */
+  const right = []
+  for (const item of sig.right) {
+    const s = normalizeSigItem(item, ctx)
+    if (!s) return null
+    right.push(s)
+  }
+  return {
+    left,
+    right,
+    effectsAdd: [...sig.effectsAdd],
+    effectsRemove: [...sig.effectsRemove]
+  }
+}
+
+/**
+ * @param {object} item
+ * @param {ReturnType<typeof makeCtx>} ctx
+ * @returns {object | null}
+ */
+/**
+ * @param {object} item
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @returns {{ ir: object | null, diagnostics: object[] }}
+ */
+export function normalizeSigItemWithEnv (item, env, modulePath) {
+  const scopeInfo = env.scopeByPath.get(modulePath)
+  if (!scopeInfo) {
+    return { ir: null, diagnostics: [] }
+  }
+  const ctx = makeCtx(env, modulePath, scopeInfo)
+  const ir = normalizeSigItem(item, ctx)
+  return { ir, diagnostics: ctx.diagnostics }
+}
+
+export function normalizeSigItem (item, ctx) {
+  switch (item.kind) {
+    case 'sig_type_expr': {
+      return normalizeTypeExpr(item.type, ctx)
+    }
+    case 'stack_var':
+      return { kind: 'stack_label', name: item.name, source: item }
+    case 'quotation_sig': {
+      const inner = normalizeSignature(item.inner, ctx)
+      if (!inner) return null
+      return { kind: 'quote', source: item, inner }
+    }
+    case 'named_quotation_sig': {
+      const inner = normalizeSignature(item.quotation.inner, ctx)
+      if (!inner) return null
+      return {
+        kind: 'named_quote',
+        prefix: item.prefix,
+        source: item,
+        inner
+      }
+    }
+    default:
+      pushDiag(
+        ctx.diagnostics,
+        item.span,
+        'E1304',
+        diag.e1304TypeMismatch('элемент сигнатуры', item.kind)
+      )
+      return null
+  }
+}
+
+/**
+ * @param {object} word
+ * @param {ReturnType<typeof makeCtx>} ctx
+ * @returns {NormalizedSignature | null}
+ */
+export function normalizeWordSignature (word, ctx) {
+  if (!word.signature) {
+    pushDiag(
+      ctx.diagnostics,
+      word.span,
+      'E1301',
+      diag.e1301WordSignature(word.name)
+    )
+    return null
+  }
+  const ir = normalizeSignature(word.signature, ctx)
+  if (!ir && ctx.diagnostics.length === 0) {
+    pushDiag(
+      ctx.diagnostics,
+      word.span,
+      'E1301',
+      diag.e1301WordSignature(word.name)
+    )
+  }
+  return ir
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @returns {{ diagnostics: object[], sigIrByPath: Map<string, Map<string, NormalizedSignature>> }}
+ */
+export function normalizeAllSignatures (env) {
+  /** @type {object[]} */
+  const allDiags = []
+  /** @type {Map<string, Map<string, NormalizedSignature>>} */
+  const sigIrByPath = new Map()
+
+  for (const p of env.modulePathsOrdered) {
+    const snap = env.snapshots.get(p)
+    const scopeInfo = env.scopeByPath.get(p)
+    const words = env.wordDeclByPath.get(p)
+    if (!snap?.ok || !scopeInfo || !words) continue
+
+    /** @type {Map<string, NormalizedSignature>} */
+    const perPath = new Map()
+
+    for (const [name, word] of words) {
+      const ctx = makeCtx(env, p, scopeInfo)
+      const ir = normalizeWordSignature(word, ctx)
+      if (ctx.diagnostics.length > 0) {
+        allDiags.push(...ctx.diagnostics)
+      }
+      if (ir) {
+        perPath.set(name, ir)
+      }
+    }
+    sigIrByPath.set(p, perPath)
+  }
+
+  return { diagnostics: allDiags, sigIrByPath }
+}

package/lib/typecheck/stack-step-snapshots.js

@@ -0,0 +1,56 @@
+/**
+ * L3 этап 9: снимки стека по шагам для RFC-IR-0.1 §3, RFC-typecheck-0.1 §3 и §6.
+ * Полная цепочка на каждый шаг (сжатие до базовых блоков не делаем — см. RFC-IR §3).
+ */
+import { applySubstDeep, unifyTypes } from './unify-type.js'
+
+/**
+ * @typedef {{ pre: object[], post: object[] }} StackStepSnapshot
+ */
+
+/**
+ * @typedef {object} WordStackSnapshotRecord
+ * @property {StackStepSnapshot[]} steps индекс = индекс шага в `word.body` (дно→вершина в pre/post)
+ * @property {Map<number, WordStackSnapshotRecord>} nestedByParentStep вложенные цитаты по индексу шага `( … )`
+ */
+
+/**
+ * Копия стека для снимка: слоты после текущей подстановки (читаемо снаружи без повторного вывода).
+ *
+ * @param {object[]} stack
+ * @param {WeakMap<object, object>} subst
+ * @returns {object[]}
+ */
+export function snapshotStackSlots (stack, subst) {
+  return stack.map((t) => applySubstDeep(t, subst))
+}
+
+/**
+ * RFC-IR-0.1 §3 п.2: для валидной цепочки post[i] унифицируется с pre[i+1].
+ *
+ * @param {WordStackSnapshotRecord} record
+ * @returns {boolean}
+ */
+export function verifySnapshotChainStitches (record) {
+  const steps = record.steps
+  for (let i = 0; i < steps.length - 1; i++) {
+    const cur = steps[i]
+    const next = steps[i + 1]
+    if (cur == null || next == null) continue
+    const a = cur.post
+    const b = next.pre
+    if (a == null || b == null || !Array.isArray(a) || !Array.isArray(b)) {
+      continue
+    }
+    if (a.length !== b.length) return false
+    const subst = new WeakMap()
+    const diags = []
+    for (let j = 0; j < a.length; j++) {
+      if (!unifyTypes(a[j], b[j], subst, diags, null)) return false
+    }
+  }
+  for (const nested of record.nestedByParentStep.values()) {
+    if (!verifySnapshotChainStitches(nested)) return false
+  }
+  return true
+}