@algosail/lang 0.2.12 → 0.5.1

package/lib/codegen/compile-graph.js

@@ -0,0 +1,107 @@
+/**
+ * L5: обход модулей после успешного typecheck; эмиссия ESM по модулю (RFC-compile §4, §9).
+ */
+import path from 'node:path'
+import { e5301ReadFileRequired, e5302CannotReadFfi } from './codegen-diagnostics.js'
+import { emitModuleEsmSource } from './emit-module.js'
+import {
+  isPathInsideSourceRoot,
+  projectJsFileToOutputPath,
+  sailModuleToOutputJsPath
+} from './out-layout.js'
+
+/**
+ * Проектные FFI `.js` для зеркала в `out-dir`: только импорты с относительным `path` в `.sail`
+ * (`./` / `../`). Пакеты npm (`@scope/pkg/…`, bare) не копируются — в ESM остаётся тот же
+ * спецификатор, резолв через `node_modules` (RFC-compile §9.2).
+ *
+ * @param {object} env
+ * @param {string} sourceRoot
+ * @returns {Set<string>}
+ */
+export function collectProjectFfiJsPathsForCodegenCopy (env, sourceRoot) {
+  /** @type {Set<string>} */
+  const set = new Set()
+  for (const modPath of env.modulePathsOrdered) {
+    const normMod = path.normalize(modPath)
+    if (path.extname(normMod).toLowerCase() !== '.sail') continue
+    const snap = env.snapshots.get(normMod)
+    const scope = env.scopeByPath.get(normMod)
+    if (!snap?.ok || !Array.isArray(snap.items) || !scope?.importMap) continue
+    for (const item of snap.items) {
+      if (item.kind !== 'import') continue
+      const spec = item.path
+      if (typeof spec !== 'string') continue
+      if (!spec.startsWith('./') && !spec.startsWith('../')) continue
+      const dep = scope.importMap.get(item.module)
+      const p =
+        dep != null && typeof dep === 'object' && typeof dep.path === 'string'
+          ? dep.path
+          : null
+      if (p == null) continue
+      const abs = path.normalize(p)
+      if (path.extname(abs).toLowerCase() !== '.js') continue
+      if (!isPathInsideSourceRoot(abs, sourceRoot)) continue
+      set.add(abs)
+    }
+  }
+  return set
+}
+
+/**
+ * @param {object} env — `TypecheckEnv` после успешного `typecheckSail` (`modulePathsOrdered`, …)
+ * @param {{ outDir: string, sourceRoot: string, entryPath: string }} layout — {@link resolveCompileLayout}
+ * @param {{ mkdir: (p: string, opts?: { recursive?: boolean }) => Promise<void>, writeFile: (p: string, data: string) => Promise<void> }} fsSink
+ * @param {(p: string) => string | null | undefined} readFile — для копирования проектных FFI `.js` (RFC-compile §9.1)
+ * @returns {Promise<{ ok: true, diagnostics: [], emitted: string[] } | { ok: false, diagnostics: object[], emitted: [] }>}
+ */
+export async function emitCodegenStage0Stub (env, layout, fsSink, readFile) {
+  /** @type {string[]} */
+  const emitted = []
+  const sourceRoot = layout.sourceRoot
+
+  const ffiSet = collectProjectFfiJsPathsForCodegenCopy(env, sourceRoot)
+  const ffiSorted = [...ffiSet].sort()
+  if (ffiSorted.length > 0 && typeof readFile !== 'function') {
+    return {
+      ok: false,
+      diagnostics: [e5301ReadFileRequired()],
+      emitted: []
+    }
+  }
+
+  for (const jsPath of ffiSorted) {
+    const mapped = projectJsFileToOutputPath(layout, jsPath)
+    if (!mapped.ok) {
+      return { ok: false, diagnostics: [mapped.diagnostic], emitted: [] }
+    }
+    const text = readFile(jsPath)
+    if (text == null || text === undefined) {
+      return {
+        ok: false,
+        diagnostics: [e5302CannotReadFfi(jsPath)],
+        emitted: []
+      }
+    }
+    await fsSink.mkdir(path.dirname(mapped.path), { recursive: true })
+    await fsSink.writeFile(mapped.path, text)
+    emitted.push(mapped.path)
+  }
+
+  for (const modPath of env.modulePathsOrdered) {
+    const norm = path.normalize(modPath)
+    if (path.extname(norm).toLowerCase() !== '.sail') continue
+    const mapped = sailModuleToOutputJsPath(layout, norm)
+    if (!mapped.ok) {
+      return { ok: false, diagnostics: [mapped.diagnostic], emitted: [] }
+    }
+    const gen = emitModuleEsmSource({ env, modulePath: norm, layout })
+    if (!gen.ok) {
+      return { ok: false, diagnostics: gen.diagnostics, emitted: [] }
+    }
+    await fsSink.mkdir(path.dirname(mapped.path), { recursive: true })
+    await fsSink.writeFile(mapped.path, gen.source)
+    emitted.push(mapped.path)
+  }
+  return { ok: true, diagnostics: [], emitted }
+}

package/lib/codegen/emit-adt.js

@@ -0,0 +1,177 @@
+/**
+ * L5 этап 6: тела автоген-слов ADT (RFC-0.1 §7, RFC-compile §8).
+ * Без синтетического IR в buildModuleIr: только строка тела для локальной `function`.
+ */
+import { lowerFirst } from '../names/lower-first.js'
+
+/**
+ * @typedef {import('../typecheck/normalize-sig.js').NormalizedSignature} NormalizedSignature
+ */
+
+/**
+ * @param {string} wordName
+ * @param {{ kind: string, ast: object }} adtEntry
+ * @returns {{
+ *   kind: 'sum_elim'|'sum_ctor'|'prod_ctor'|'prod_get'|'prod_with'
+ *   ast: object
+ *   tag?: object
+ *   field?: object
+ * } | null}
+ */
+export function classifyAutogenWord (wordName, adtEntry) {
+  const ast = adtEntry.ast
+  if (adtEntry.kind === 'sum') {
+    const elim = lowerFirst(ast.name)
+    if (wordName === elim) return { kind: 'sum_elim', ast }
+    for (const tag of ast.tags ?? []) {
+      if (lowerFirst(tag.name) === wordName) {
+        return { kind: 'sum_ctor', ast, tag }
+      }
+    }
+  } else if (adtEntry.kind === 'product') {
+    if (lowerFirst(ast.name) === wordName) return { kind: 'prod_ctor', ast }
+    const withN = lowerFirst(`with${ast.name}`)
+    if (wordName === withN) return { kind: 'prod_with', ast }
+    for (const f of ast.fields ?? []) {
+      if (lowerFirst(f.name + ast.name) === wordName) {
+        return { kind: 'prod_get', ast, field: f }
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * @param {import('../typecheck/build-type-env.js').TypecheckEnv} env
+ * @param {string} modulePath
+ * @param {string} wordName
+ * @returns {ReturnType<typeof classifyAutogenWord>}
+ */
+export function findAutogenRoleInModule (env, modulePath, wordName) {
+  const adtMap = env.adtByPath?.get(modulePath)
+  if (!(adtMap instanceof Map)) return null
+  for (const entry of adtMap.values()) {
+    const role = classifyAutogenWord(wordName, entry)
+    if (role) return role
+  }
+  return null
+}
+
+/**
+ * @param {object} sumAst
+ */
+function emitSumEliminatorBody (sumAst) {
+  const tags = sumAst.tags ?? []
+  const n = tags.length
+  const pNames = tags.map((_, i) => `p${i + 1}`)
+  const declP = pNames.length ? `, ${pNames.join(', ')}` : ''
+  /** @type {string[]} */
+  const lines = [
+    `const nB = ${n}`,
+    `let s0, d${declP}`,
+    'if (arguments.length === nB + 1) {',
+    '  s0 = undefined',
+    '  d = arguments[0]'
+  ]
+  for (let i = 0; i < n; i++) {
+    lines.push(`  ${pNames[i]} = arguments[${i + 1}]`)
+  }
+  lines.push(
+    '} else if (arguments.length === nB + 2) {',
+    '  s0 = arguments[0]',
+    '  d = arguments[1]'
+  )
+  for (let i = 0; i < n; i++) {
+    lines.push(`  ${pNames[i]} = arguments[${i + 2}]`)
+  }
+  lines.push(
+    '} else {',
+    `  throw new Error(${JSON.stringify('ADT eliminator: неверное число аргументов')})`,
+    '}'
+  )
+  for (let i = 0; i < n; i++) {
+    const tag = tags[i]
+    const tname = JSON.stringify(tag.name)
+    if (tag.payload) {
+      lines.push(`if (d.tag === ${tname}) return ${pNames[i]}(s0, d.value);`)
+    } else {
+      lines.push(`if (d.tag === ${tname}) return ${pNames[i]}(s0);`)
+    }
+  }
+  lines.push(
+    `throw new Error(${JSON.stringify('ADT eliminator: неизвестный tag')});`
+  )
+  return lines.join('\n')
+}
+
+/**
+ * Список формальных параметров для `function name(…)`: eliminator — без параметров (`arguments`).
+ *
+ * @param {{ kind: string }} role
+ * @param {NormalizedSignature | null | undefined} normalizedSig
+ */
+export function formatAutogenFormalParameters (role, normalizedSig) {
+  if (role.kind === 'sum_elim') return ''
+  const left = normalizedSig != null && Array.isArray(normalizedSig.left)
+    ? normalizedSig.left
+    : []
+  if (left.length === 0) return ''
+  return Array.from({ length: left.length }, (_, i) => `p${i}`).join(', ')
+}
+
+/**
+ * @param {{ kind: string, ast: object, tag?: object, field?: object }} role
+ * @param {NormalizedSignature | null | undefined} _normalizedSig зарезервировано для будущих проверок
+ */
+export function emitAdtAutogenFunctionBody (role, _normalizedSig) {
+  switch (role.kind) {
+    case 'sum_elim':
+      return emitSumEliminatorBody(role.ast)
+    case 'sum_ctor': {
+      const tag = /** @type {{ name: string, payload?: unknown }} */ (role.tag)
+      const tname = JSON.stringify(tag.name)
+      if (tag.payload) {
+        return `return { tag: ${tname}, value: p0 };`
+      }
+      return `return { tag: ${tname} };`
+    }
+    case 'prod_ctor': {
+      const ast = role.ast
+      const fields = ast.fields ?? []
+      /** @type {string[]} */
+      const parts = []
+      for (let ix = 0; ix < fields.length; ix++) {
+        const f = /** @type {{ name: string }} */ (fields[ix])
+        parts.push(`${JSON.stringify(f.name)}: p${ix}`)
+      }
+      return `return { ${parts.join(', ')} };`
+    }
+    case 'prod_get': {
+      const field = /** @type {{ name: string }} */ (role.field)
+      const k = JSON.stringify(field.name)
+      return `return p0[${k}];`
+    }
+    case 'prod_with': {
+      const ast = role.ast
+      const fields = ast.fields ?? []
+      const acc = fields.map((/** @type {{ name: string }} */ f) => {
+        return `p0[${JSON.stringify(f.name)}]`
+      })
+      return `return p1(undefined, ${acc.join(', ')});`
+    }
+    default:
+      throw new Error(`emit-adt: неизвестный kind роли ${String(/** @type {{ kind?: string }} */ (role).kind)}`)
+  }
+}
+
+/**
+ * Имя вспомогательной функции для квалифицированного автогена (`~M/w` → не экспортируется из M).
+ *
+ * @param {string} moduleAlias
+ * @param {string} wordName
+ */
+export function mangleQualifiedAutogenName (moduleAlias, wordName) {
+  const safeA = moduleAlias.replace(/[^A-Za-z0-9_$]/g, '_')
+  const safeW = wordName.replace(/[^A-Za-z0-9_$]/g, '_')
+  return `__adt_${safeA}__${safeW}`
+}