@algosail/lang 0.2.12 → 0.5.1

package/lib/typecheck/check-word-body.js

@@ -0,0 +1,1021 @@
+/**
+ * L3: проверка тела слова по стеку (RFC-typecheck-0.1 §5.2–5.6).
+ * Снимки стека по шагам — этап 9 (RFC-IR-0.1 §3, RFC-typecheck §3, §6).
+ *
+ * Модули `.js` (FFI): контракт из `@sail` в JSDoc; тело JS не проверяется (RFC-0.1 §10.0).
+ */
+import path from 'node:path'
+import * as diag from '../parse/diagnostics.js'
+import { snapshotStackSlots } from './stack-step-snapshots.js'
+import { getBuiltinStackSignature } from './builtin-signatures.js'
+import {
+  applySubstDeep,
+  applySubstToNormSig,
+  derefType,
+  formatIrType,
+  freshInstanceSignature,
+  shareTvarsInSignature,
+  unifyStackWithOutput,
+  unifyTypes
+} from './unify-type.js'
+import {
+  calleeAsyncPropagatesToCaller,
+  calleeFailPropagatesToCaller,
+  contextAllowsAsyncCallFromCallee,
+  contextAllowsFailCallFromCallee,
+  declaredEffectFlags,
+  effectArraysFromFlags
+} from './effect-decl.js'
+
+/** Счётчик для свежих tvar пустого / полиморфного `List` в литералах `[ … ]`. */
+let listLiteralFreshSeq = 0
+
+/** @returns {{ kind: 'tvar', name: string, source: null, decl: null }} */
+function freshListLiteralElemTvar () {
+  listLiteralFreshSeq++
+  return {
+    kind: 'tvar',
+    name: `ρL${listLiteralFreshSeq}`,
+    source: null,
+    decl: null
+  }
+}
+
+/** Встроенные слова, исполняющие вложенную quotation (RFC-typecheck §5.6, §5.7 п.3). */
+const BUILTINS_EXECUTING_QUOTES = new Set([
+  'dip',
+  'keep',
+  'bi',
+  'tri',
+  'spread',
+  'both'
+])
+
+/**
+ * @param {object[]} out
+ * @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)
+}
+
+/**
+ * RFC-typecheck §3: при ошибке на шаге k сохранить `pre` стека перед шагом; `post` может отсутствовать.
+ * @param {{ steps: object[], nestedByParentStep: Map<number, object> } | null} snapshotRecord
+ * @param {number} si
+ * @param {object[] | null} preSnap
+ */
+function recordStepPreOnFailure (snapshotRecord, si, preSnap) {
+  if (snapshotRecord == null || preSnap == null) return
+  snapshotRecord.steps[si] = { pre: preSnap }
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @param {string} wordName
+ * @param {{ steps: object[], nestedByParentStep: Map<number, object> }} snapshotRecord
+ */
+function putStackSnapshotsForWord (env, modulePath, wordName, snapshotRecord) {
+  if (env.stackSnapshotsByPath == null) return
+  let perPath = env.stackSnapshotsByPath.get(modulePath)
+  if (!perPath) {
+    perPath = new Map()
+    env.stackSnapshotsByPath.set(modulePath, perPath)
+  }
+  perPath.set(wordName, snapshotRecord)
+}
+
+/** @returns {{ kind: 'prim', name: string, source: null, decl: null }} */
+function prim (name) {
+  return { kind: 'prim', name, source: null, decl: null }
+}
+
+/**
+ * @param {object} step
+ * @returns {object | null}
+ */
+function literalIrType (step) {
+  switch (step.litKind) {
+    case 'number':
+      return prim('Num')
+    case 'string':
+      return prim('Str')
+    case 'bool':
+      return prim('Bool')
+    case 'nil':
+      return prim('Nil')
+    case 'bigint':
+      return prim('Num')
+    case 'regexp':
+      return prim('Str')
+    default:
+      return null
+  }
+}
+
+/**
+ * Подпись expected для E1304 (RFC-0.1 §13) при неподдерживаемом литерале.
+ *
+ * @param {object} step
+ * @returns {string}
+ */
+function literalExpectedTypeLabel (step) {
+  switch (step.litKind) {
+    case 'number':
+    case 'bigint':
+      return 'Num'
+    case 'string':
+    case 'regexp':
+      return 'Str'
+    case 'bool':
+      return 'Bool'
+    case 'nil':
+      return 'Nil'
+    default:
+      return 'литерал'
+  }
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @param {string | null} modAlias
+ * @param {string} wordName
+ * @returns {import('./normalize-sig.js').NormalizedSignature | null}
+ */
+export function lookupWordSignatureIr (env, modulePath, modAlias, wordName) {
+  if (!modAlias) {
+    const local = env.sigIrByPath.get(modulePath)?.get(wordName) ?? null
+    if (local) return local
+
+    const snap = env.snapshots?.get(modulePath)
+    if (!snap?.ok || !Array.isArray(snap.items)) return null
+    const scope = env.scopeByPath?.get(modulePath)
+    if (!scope?.importMap) return null
+
+    let foundPath = null
+    for (const item of snap.items) {
+      if (item.kind !== 'import') continue
+      const words = item.bracket?.words
+      if (!Array.isArray(words) || !words.includes(wordName)) continue
+      const dep = scope.importMap.get(item.module)
+      const p = dep?.path
+      if (typeof p !== 'string') continue
+      if (foundPath != null && foundPath !== p) return null
+      foundPath = p
+    }
+    if (foundPath == null) return null
+    return env.sigIrByPath.get(foundPath)?.get(wordName) ?? null
+  }
+  const dep = env.scopeByPath.get(modulePath)?.importMap.get(modAlias)
+  const p = dep?.path
+  if (!p) return null
+  return env.sigIrByPath.get(p)?.get(wordName) ?? null
+}
+
+/**
+ * @param {object[]} stack
+ * @param {import('./normalize-sig.js').NormalizedSignature} calleeFresh
+ * @param {WeakMap<object, object>} subst
+ * @param {object[]} diags
+ * @param {object | null} span
+ * @returns {boolean}
+ */
+function applyCalleeStackEffect (stack, calleeFresh, subst, diags, span) {
+  const k = calleeFresh.left.length
+  if (stack.length < k) {
+    pushDiag(
+      diags,
+      span,
+      'E1303',
+      diag.e1303StackEffect(
+        `минимум ${k} слотов на входе`,
+        `${stack.length} слотов`
+      )
+    )
+    return false
+  }
+  const base = stack.length - k
+  for (let i = 0; i < k; i++) {
+    if (
+      !unifyTypes(
+        stack[base + i],
+        calleeFresh.left[i],
+        subst,
+        diags,
+        span
+      )
+    ) {
+      return false
+    }
+  }
+  const pref = stack.slice(0, base)
+  const outSlots = calleeFresh.right.map((t) => applySubstDeep(t, subst))
+  stack.length = 0
+  stack.push(...pref, ...outSlots)
+  return true
+}
+
+/**
+ * ADT eliminator: E1308 при недостатке слотов, E1307 при сбое унификации веток (RFC-0.1 §13).
+ *
+ * @param {string} calleeDisplayName
+ */
+function applyCalleeStackEffectForWordRef (
+  stack,
+  calleeFresh,
+  subst,
+  diags,
+  span,
+  calleeDisplayName
+) {
+  const k = calleeFresh.left.length
+  if (calleeFresh.adtEliminator && stack.length < k) {
+    pushDiag(
+      diags,
+      span,
+      'E1308',
+      diag.e1308EliminatorQuotes(calleeDisplayName)
+    )
+    return false
+  }
+  const ok = applyCalleeStackEffect(stack, calleeFresh, subst, diags, span)
+  if (!ok && calleeFresh.adtEliminator) {
+    pushDiag(diags, span, 'E1307', diag.e1307EliminatorBranches())
+  }
+  return ok
+}
+
+/**
+ * @param {object[]} stack
+ * @param {import('./normalize-sig.js').NormalizedSignature} calleeFresh
+ * @param {WeakMap<object, object>} subst
+ * @returns {import('./normalize-sig.js').NormalizedSignature[]}
+ */
+function collectQuoteInnersFromStackInputs (stack, calleeFresh, subst) {
+  const k = calleeFresh.left.length
+  const base = stack.length - k
+  /** @type {import('./normalize-sig.js').NormalizedSignature[]} */
+  const out = []
+  for (let i = 0; i < k; i++) {
+    const req = calleeFresh.left[i]
+    if (req.kind !== 'quote' && req.kind !== 'named_quote') continue
+    const concrete = derefType(stack[base + i], subst)
+    if (
+      concrete &&
+      (concrete.kind === 'quote' || concrete.kind === 'named_quote')
+    ) {
+      out.push(applySubstToNormSig(concrete.inner, subst))
+    }
+  }
+  return out
+}
+
+/**
+ * @param {import('./effect-decl.js').EffectFlags} containerEff
+ * @param {import('./normalize-sig.js').NormalizedSignature} executedSig
+ * @param {boolean} quotationInferOpen
+ */
+function checkExecutedNormSigEffects (
+  containerEff,
+  executedSig,
+  diags,
+  span,
+  callerWordName,
+  calleeLabel,
+  quotationInferOpen
+) {
+  const f = declaredEffectFlags(executedSig)
+  if (calleeAsyncPropagatesToCaller(f)) {
+    if (!contextAllowsAsyncCallFromCallee(containerEff)) {
+      if (quotationInferOpen) {
+        containerEff.plusAsync = true
+      } else {
+        pushDiag(
+          diags,
+          span,
+          'E1310',
+          diag.e1310AsyncCall(calleeLabel, callerWordName)
+        )
+        return false
+      }
+    }
+  }
+  if (calleeFailPropagatesToCaller(f)) {
+    if (!contextAllowsFailCallFromCallee(containerEff)) {
+      if (quotationInferOpen) {
+        containerEff.plusFail = true
+      } else {
+        pushDiag(
+          diags,
+          span,
+          'E1312',
+          diag.e1312FailCall(calleeLabel, callerWordName)
+        )
+        return false
+      }
+    }
+  }
+  return true
+}
+
+/**
+ * @param {import('./effect-decl.js').EffectFlags} containerEff
+ */
+function ensureCalleeWordEffects (
+  containerEff,
+  calleeIr,
+  quotationInferOpen,
+  diags,
+  span,
+  callerWordName,
+  calleeLabel
+) {
+  return checkExecutedNormSigEffects(
+    containerEff,
+    calleeIr,
+    diags,
+    span,
+    callerWordName,
+    calleeLabel,
+    quotationInferOpen
+  )
+}
+
+/**
+ * L3 маркер → IR §6: `calleeAsync` не ставить при поглощении исходящим `-Async` (RFC-compile §10.5, вариант B).
+ *
+ * @param {import('./effect-decl.js').EffectFlags} calleeFlags
+ * @param {import('./effect-decl.js').EffectFlags} containerEff
+ */
+function markCalleeAsyncForIr (calleeFlags, containerEff) {
+  return calleeAsyncPropagatesToCaller(calleeFlags) && !containerEff.minusAsync
+}
+
+/**
+ * @param {import('./effect-decl.js').EffectFlags} calleeFlags
+ * @param {import('./effect-decl.js').EffectFlags} containerEff
+ */
+function markCalleeMayFailForIr (calleeFlags, containerEff) {
+  return calleeFailPropagatesToCaller(calleeFlags) && !containerEff.minusFail
+}
+
+/**
+ * RFC-builtins §4.3: ( ~rest I… Quote(I->O) -> ~rest O… ), длина I задаётся вложенной сигнатурой.
+ *
+ * @param {object[]} stack
+ * @param {WeakMap<object, object>} subst
+ * @param {object[]} diags
+ * @param {object | null} span
+ * @param {import('./effect-decl.js').EffectFlags} containerEff
+ * @param {string} callerWordName
+ * @param {string} modulePath
+ * @param {object[] | null} callSiteMarks
+ * @param {boolean} quotationInferOpen
+ * @returns {boolean}
+ */
+function applyCallStack (
+  stack,
+  subst,
+  diags,
+  span,
+  containerEff,
+  callerWordName,
+  modulePath,
+  callSiteMarks,
+  quotationInferOpen
+) {
+  if (stack.length < 1) {
+    pushDiag(
+      diags,
+      span,
+      'E1303',
+      diag.e1303StackEffect('call: quotation на вершине', 'пустой стек')
+    )
+    return false
+  }
+  const qi = stack.length - 1
+  const top = derefType(stack[qi], subst)
+  if (
+    !top ||
+    (top.kind !== 'quote' && top.kind !== 'named_quote')
+  ) {
+    pushDiag(
+      diags,
+      span,
+      'E1306',
+      diag.e1306CallNeedsQuote(top ? formatIrType(top) : 'пусто')
+    )
+    return false
+  }
+  const innerResolved = applySubstToNormSig(top.inner, subst)
+  if (
+    !checkExecutedNormSigEffects(
+      containerEff,
+      innerResolved,
+      diags,
+      span,
+      callerWordName,
+      'call',
+      quotationInferOpen
+    )
+  ) {
+    return false
+  }
+  if (callSiteMarks) {
+    const cf = declaredEffectFlags(innerResolved)
+    callSiteMarks.push({
+      modulePath,
+      kind: 'call',
+      span,
+      calleeAsync: markCalleeAsyncForIr(cf, containerEff),
+      calleeMayFail: markCalleeMayFailForIr(cf, containerEff)
+    })
+  }
+  stack.splice(qi, 1)
+  const inner = top.inner
+  const n = inner.left.length
+  if (stack.length < n) {
+    pushDiag(
+      diags,
+      span,
+      'E1303',
+      diag.e1303StackEffect(
+        `call: минимум ${n} слотов под вход quotation`,
+        `${stack.length} слотов`
+      )
+    )
+    return false
+  }
+  const base = stack.length - n
+  for (let i = 0; i < n; i++) {
+    if (
+      !unifyTypes(
+        stack[base + i],
+        inner.left[i],
+        subst,
+        diags,
+        span
+      )
+    ) {
+      return false
+    }
+  }
+  const pref = stack.slice(0, base)
+  const outSlots = inner.right.map((t) => applySubstDeep(t, subst))
+  stack.length = 0
+  stack.push(...pref, ...outSlots)
+  return true
+}
+
+/**
+ * @param {object | null} quoteExpectation — IR `quote` / `named_quote` из объявленного выхода слова (RFC-typecheck §5.6 п.4).
+ * @param {import('./effect-decl.js').EffectFlags} containerEff — контекст всплытия (слово или вложенная quotation_sig).
+ * @param {boolean} quotationInferOpen — тело открытой цитаты без ожидаемой inner-сигнатуры (инфер +Async/+Fail).
+ * @param {object[] | null} callSiteMarks — накопление для RFC-IR §6 / RFC-typecheck §3.
+ * @param {{ steps: object[], nestedByParentStep: Map<number, object> } | null} snapshotRecord этап 9: цепочка pre/post (`post` опционален на шаге с ошибкой; RFC-typecheck §3); null — не писать снимки.
+ */
+function walkWordSteps (
+  env,
+  modulePath,
+  body,
+  stack,
+  slots,
+  subst,
+  diags,
+  defaultSpan,
+  quoteExpectation,
+  containerEff,
+  quotationInferOpen,
+  callerWordName,
+  callSiteMarks,
+  snapshotRecord
+) {
+  for (let si = 0; si < body.length; si++) {
+    const step = body[si]
+    const sp = step.span ?? defaultSpan
+    const preSnap =
+      snapshotRecord != null ? snapshotStackSlots(stack, subst) : null
+    const failWithPre = () => {
+      recordStepPreOnFailure(snapshotRecord, si, preSnap)
+      return false
+    }
+    switch (step.kind) {
+      case 'literal': {
+        const ty = literalIrType(step)
+        if (!ty) {
+          pushDiag(
+            diags,
+            sp,
+            'E1304',
+            diag.e1304TypeMismatch(literalExpectedTypeLabel(step), step.litKind)
+          )
+          return failWithPre()
+        }
+        stack.push(ty)
+        break
+      }
+      case 'builtin': {
+        const nm = step.name
+        if (nm === 'call') {
+          if (
+            !applyCallStack(
+              stack,
+              subst,
+              diags,
+              sp,
+              containerEff,
+              callerWordName,
+              modulePath,
+              callSiteMarks,
+              quotationInferOpen
+            )
+          ) {
+            return failWithPre()
+          }
+          break
+        }
+        const template = getBuiltinStackSignature(nm)
+        if (template) {
+          const inst = freshInstanceSignature(shareTvarsInSignature(template))
+          if (BUILTINS_EXECUTING_QUOTES.has(nm)) {
+            const inners = collectQuoteInnersFromStackInputs(
+              stack,
+              inst,
+              subst
+            )
+            for (const innerSig of inners) {
+              if (
+                !checkExecutedNormSigEffects(
+                  containerEff,
+                  innerSig,
+                  diags,
+                  sp,
+                  callerWordName,
+                  nm,
+                  quotationInferOpen
+                )
+              ) {
+                return failWithPre()
+              }
+            }
+            if (callSiteMarks) {
+              for (const innerSig of inners) {
+                const cf = declaredEffectFlags(innerSig)
+                callSiteMarks.push({
+                  modulePath,
+                  kind: 'builtin_quote',
+                  builtin: nm,
+                  span: sp,
+                  calleeAsync: markCalleeAsyncForIr(cf, containerEff),
+                  calleeMayFail: markCalleeMayFailForIr(cf, containerEff)
+                })
+              }
+            }
+          }
+          if (!applyCalleeStackEffect(stack, inst, subst, diags, sp)) {
+            return failWithPre()
+          }
+          break
+        }
+        pushDiag(diags, sp, 'E1206', diag.e1206UnknownBuiltin(nm))
+        return failWithPre()
+      }
+      case 'word_ref': {
+        const calleeIr = lookupWordSignatureIr(env, modulePath, null, step.name)
+        if (!calleeIr) {
+          pushDiag(diags, sp, 'E1304', diag.e1304UnknownTypeInSignature(step.name))
+          return failWithPre()
+        }
+        if (
+          !ensureCalleeWordEffects(
+            containerEff,
+            calleeIr,
+            quotationInferOpen,
+            diags,
+            sp,
+            callerWordName,
+            step.name
+          )
+        ) {
+          return failWithPre()
+        }
+        if (callSiteMarks) {
+          const cf = declaredEffectFlags(calleeIr)
+          callSiteMarks.push({
+            modulePath,
+            kind: 'word_ref',
+            name: step.name,
+            span: sp,
+            calleeAsync: markCalleeAsyncForIr(cf, containerEff),
+            calleeMayFail: markCalleeMayFailForIr(cf, containerEff)
+          })
+        }
+        const inst = freshInstanceSignature(shareTvarsInSignature(calleeIr))
+        if (
+          !applyCalleeStackEffectForWordRef(
+            stack,
+            inst,
+            subst,
+            diags,
+            sp,
+            step.name
+          )
+        ) {
+          return failWithPre()
+        }
+        break
+      }
+      case 'module_word_ref': {
+        const calleeIr = lookupWordSignatureIr(
+          env,
+          modulePath,
+          step.module,
+          step.word
+        )
+        if (!calleeIr) {
+          pushDiag(
+            diags,
+            sp,
+            'E1204',
+            diag.e1204MissingMember(step.module, step.word)
+          )
+          return failWithPre()
+        }
+        const qual = `~${step.module}/${step.word}`
+        if (
+          !ensureCalleeWordEffects(
+            containerEff,
+            calleeIr,
+            quotationInferOpen,
+            diags,
+            sp,
+            callerWordName,
+            qual
+          )
+        ) {
+          return failWithPre()
+        }
+        if (callSiteMarks) {
+          const cf = declaredEffectFlags(calleeIr)
+          callSiteMarks.push({
+            modulePath,
+            kind: 'module_word_ref',
+            module: step.module,
+            word: step.word,
+            span: sp,
+            calleeAsync: markCalleeAsyncForIr(cf, containerEff),
+            calleeMayFail: markCalleeMayFailForIr(cf, containerEff)
+          })
+        }
+        const inst = freshInstanceSignature(shareTvarsInSignature(calleeIr))
+        if (
+          !applyCalleeStackEffectForWordRef(
+            stack,
+            inst,
+            subst,
+            diags,
+            sp,
+            qual
+          )
+        ) {
+          return failWithPre()
+        }
+        break
+      }
+      case 'quotation': {
+        const bodySteps = step.body ?? []
+        const exp = quoteExpectation
+        const expInner =
+          exp && (exp.kind === 'quote' || exp.kind === 'named_quote')
+            ? exp.inner
+            : null
+
+        if (bodySteps.length === 0 && !expInner) {
+          stack.push({
+            kind: 'quote',
+            source: step,
+            inner: {
+              left: [],
+              right: [],
+              effectsAdd: [],
+              effectsRemove: []
+            }
+          })
+          break
+        }
+
+        let innerDecl
+        let inferOpenQuote = false
+        if (expInner) {
+          innerDecl = freshInstanceSignature(
+            shareTvarsInSignature(expInner)
+          )
+        } else {
+          inferOpenQuote = true
+          const leftSeed =
+            bodySteps.length > 0
+              ? stack.map((slot) => slot)
+              : []
+          innerDecl = freshInstanceSignature(
+            shareTvarsInSignature({
+              left: leftSeed,
+              right: [],
+              effectsAdd: [],
+              effectsRemove: []
+            })
+          )
+        }
+        /** @type {import('./effect-decl.js').EffectFlags} */
+        const innerContainerEff = inferOpenQuote
+          ? {
+              plusAsync: false,
+              minusAsync: containerEff.minusAsync,
+              plusFail: false,
+              minusFail: containerEff.minusFail
+            }
+          : { ...declaredEffectFlags(innerDecl) }
+        const innerStack = innerDecl.left.slice()
+        const innerSlots = new Map()
+        const innerSnapshotRecord =
+          snapshotRecord != null
+            ? { steps: [], nestedByParentStep: new Map() }
+            : null
+        if (
+          !walkWordSteps(
+            env,
+            modulePath,
+            bodySteps,
+            innerStack,
+            innerSlots,
+            subst,
+            diags,
+            sp,
+            null,
+            innerContainerEff,
+            inferOpenQuote,
+            callerWordName,
+            callSiteMarks,
+            innerSnapshotRecord
+          )
+        ) {
+          if (snapshotRecord != null && innerSnapshotRecord != null) {
+            snapshotRecord.nestedByParentStep.set(si, innerSnapshotRecord)
+          }
+          return failWithPre()
+        }
+        if (snapshotRecord != null && innerSnapshotRecord != null) {
+          snapshotRecord.nestedByParentStep.set(si, innerSnapshotRecord)
+        }
+        if (!inferOpenQuote) {
+          const rightExpected = innerDecl.right.map((t) =>
+            applySubstDeep(t, subst)
+          )
+          const stackD = innerStack.map((t) => applySubstDeep(t, subst))
+          if (
+            !unifyStackWithOutput(stackD, rightExpected, subst, diags, sp)
+          ) {
+            return failWithPre()
+          }
+        }
+        const leftIr = innerDecl.left.map((t) => applySubstDeep(t, subst))
+        const rightIr = innerStack.map((t) => applySubstDeep(t, subst))
+        const eff = effectArraysFromFlags(innerContainerEff, sp)
+        const innerNode = {
+          left: leftIr,
+          right: rightIr,
+          effectsAdd: eff.effectsAdd,
+          effectsRemove: eff.effectsRemove
+        }
+        if (exp && exp.kind === 'named_quote') {
+          stack.push({
+            kind: 'named_quote',
+            prefix: exp.prefix,
+            source: step,
+            inner: innerNode
+          })
+        } else {
+          stack.push({
+            kind: 'quote',
+            source: step,
+            inner: innerNode
+          })
+        }
+        break
+      }
+      case 'list_literal': {
+        const elements = step.elements ?? []
+        /** @type {object | null} */
+        let elemTy = null
+        if (elements.length === 0) {
+          elemTy = freshListLiteralElemTvar()
+        } else {
+          for (const el of elements) {
+            if (el.kind !== 'literal') {
+              pushDiag(
+                diags,
+                sp,
+                'E1304',
+                diag.e1304TypeMismatch('list_literal', 'только литералы')
+              )
+              return failWithPre()
+            }
+            const ty = literalIrType(el)
+            if (!ty) {
+              pushDiag(
+                diags,
+                sp,
+                'E1304',
+                diag.e1304TypeMismatch(literalExpectedTypeLabel(el), el.litKind)
+              )
+              return failWithPre()
+            }
+            if (elemTy == null) {
+              elemTy = ty
+            } else if (!unifyTypes(elemTy, ty, subst, diags, sp)) {
+              return failWithPre()
+            }
+          }
+        }
+        stack.push({
+          kind: 'app',
+          ctor: 'List',
+          args: [applySubstDeep(/** @type {object} */ (elemTy), subst)],
+          source: null,
+          decl: null
+        })
+        break
+      }
+      case 'slot_write': {
+        if (stack.length < 1) {
+          pushDiag(
+            diags,
+            sp,
+            'E1303',
+            diag.e1303StackEffect('1 слот для :slot', 'пустой стек')
+          )
+          return failWithPre()
+        }
+        if (slots.has(step.name)) {
+          pushDiag(diags, sp, 'E1313', diag.e1313DuplicateSlotWrite(step.name))
+          return failWithPre()
+        }
+        const top = stack.pop()
+        slots.set(step.name, derefType(top, subst))
+        break
+      }
+      case 'slot_read': {
+        if (!slots.has(step.name)) {
+          pushDiag(diags, sp, 'E1314', diag.e1314SlotReadBeforeWrite(step.name))
+          return failWithPre()
+        }
+        const t = slots.get(step.name)
+        stack.push(applySubstDeep(t, subst))
+        break
+      }
+      default:
+        pushDiag(
+          diags,
+          sp,
+          'E1304',
+          diag.e1304TypeMismatch('известный word_step', step.kind)
+        )
+        return failWithPre()
+    }
+    for (let i = 0; i < stack.length; i++) {
+      stack[i] = applySubstDeep(stack[i], subst)
+    }
+    if (snapshotRecord != null && preSnap != null) {
+      snapshotRecord.steps[si] = {
+        pre: preSnap,
+        post: snapshotStackSlots(stack, subst)
+      }
+    }
+  }
+  return true
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @param {object} word
+ * @param {object[]} diags
+ * @returns {boolean}
+ */
+export function checkWordBody (env, modulePath, word, diags) {
+  const rawSig = env.sigIrByPath?.get(modulePath)?.get(word.name)
+  if (!rawSig) {
+    pushDiag(
+      diags,
+      word.span,
+      'E1304',
+      diag.e1304UnknownTypeInSignature(word.name)
+    )
+    return false
+  }
+
+  const declSig = freshInstanceSignature(shareTvarsInSignature(rawSig))
+  const subst = new WeakMap()
+  /** @type {object[]} */
+  const stack = declSig.left.slice()
+  /** @type {Map<string, object>} */
+  const slots = new Map()
+
+  const defaultSpan = word.signature?.span ?? word.span
+  const rq =
+    word.body.length === 1 && word.body[0].kind === 'quotation'
+      ? declSig.right.length === 1
+        ? declSig.right[0]
+        : null
+      : null
+  const quoteExpect =
+    rq && (rq.kind === 'quote' || rq.kind === 'named_quote') ? rq : null
+
+  const containerEff = { ...declaredEffectFlags(declSig) }
+  /** @type {object[]} */
+  const callSiteMarks = []
+
+  /** @type {{ steps: object[], nestedByParentStep: Map<number, object> }} */
+  const snapshotRecord = { steps: [], nestedByParentStep: new Map() }
+
+  if (
+    !walkWordSteps(
+      env,
+      modulePath,
+      word.body,
+      stack,
+      slots,
+      subst,
+      diags,
+      defaultSpan,
+      quoteExpect,
+      containerEff,
+      false,
+      word.name,
+      callSiteMarks,
+      env.stackSnapshotsByPath != null ? snapshotRecord : null
+    )
+  ) {
+    putStackSnapshotsForWord(env, modulePath, word.name, snapshotRecord)
+    return false
+  }
+
+  for (const m of callSiteMarks) {
+    env.callSiteEffectMarks.push({ ...m, callerWord: word.name })
+  }
+
+  const outExpected = declSig.right.map((t) => applySubstDeep(t, subst))
+  const stackD = stack.map((t) => applySubstDeep(t, subst))
+  if (!unifyStackWithOutput(stackD, outExpected, subst, diags, defaultSpan)) {
+    putStackSnapshotsForWord(env, modulePath, word.name, snapshotRecord)
+    return false
+  }
+  putStackSnapshotsForWord(env, modulePath, word.name, snapshotRecord)
+  return true
+}
+
+/**
+ * @param {import('./build-type-env.js').TypecheckEnv} env
+ * @returns {object[]}
+ */
+export function checkAllWordBodies (env) {
+  /** @type {object[]} */
+  const diags = []
+
+  /** @type {Map<string, Map<string, { asyncDefinition: boolean, mayFail: boolean }>>} */
+  const defFx = new Map()
+  for (const p of env.modulePathsOrdered) {
+    const sigs = env.sigIrByPath?.get(p)
+    /** @type {Map<string, { asyncDefinition: boolean, mayFail: boolean }>} */
+    const m = new Map()
+    if (sigs) {
+      for (const [name, sig] of sigs) {
+        const f = declaredEffectFlags(sig)
+        m.set(name, { asyncDefinition: f.plusAsync, mayFail: f.plusFail })
+      }
+    }
+    defFx.set(p, m)
+  }
+  env.definitionEffectsByPath = defFx
+  env.callSiteEffectMarks = []
+  env.stackSnapshotsByPath = new Map()
+
+  for (const p of env.modulePathsOrdered) {
+    const words = env.wordDeclByPath.get(p)
+    if (!words) continue
+    if (path.extname(p).toLowerCase() === '.js') continue
+    for (const word of words.values()) {
+      checkWordBody(env, p, word, diags)
+    }
+  }
+  return diags
+}