@algosail/lang 0.2.12 → 0.5.1

package/lib/names/resolve-sail.js

@@ -0,0 +1,365 @@
+/**
+ * L2: резолв имён по RFC-0.1 §4.2, §7, §9, §11; диагностики E11xx/E12xx.
+ */
+import path from 'node:path'
+import { parseSource } from '../parse/index.js'
+import { isBuiltinWord } from '../parse/builtins-set.js'
+import * as diag from '../parse/diagnostics.js'
+import { extractSailFragmentsFromJs } from '../ffi/extract-jsdoc-sail.js'
+import { analyzeLocalDeclarations } from './local-declarations.js'
+import { resolveImportPath } from './import-path.js'
+import { buildScopeForSnapshot, moduleExportsWord } from './module-scope.js'
+import { walkWordDecl } from './walk-ast-refs.js'
+
+/**
+ * @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)
+}
+
+/**
+ * @param {string} sourceText
+ * @param {object[]} into
+ * @returns {{ kind: 'source_file', items: object[], span: object }}
+ */
+function parseJsContractAst (sourceText, into) {
+  const frags = extractSailFragmentsFromJs(sourceText)
+  const items = []
+  const seenW = new Set()
+  const dummySpan = {
+    start: { offset: 0, line: 1, column: 1 },
+    end: { offset: 0, line: 1, column: 1 }
+  }
+  for (const frag of frags) {
+    const r = parseSource(frag)
+    if (!r.ok || !r.ast?.items?.length) {
+      into.push({
+        code: 'E1113',
+        message: diag.e1113InvalidJsSailJSDoc(),
+        offset: 0,
+        line: 1,
+        column: 1
+      })
+      continue
+    }
+    /** @type {object[]} */
+    const chunk = []
+    const localW = new Set()
+    let skip = false
+    for (const it of r.ast.items) {
+      if (it.kind === 'word') {
+        if (seenW.has(it.name)) {
+          pushDiag(into, it.span, 'E1106', diag.e1106DuplicateJsSailBlock(it.name))
+          skip = true
+          break
+        }
+        if (localW.has(it.name)) {
+          pushDiag(into, it.span, 'E1101', diag.e1101DuplicateWord(it.name))
+          skip = true
+          break
+        }
+        localW.add(it.name)
+        chunk.push(it)
+        continue
+      }
+      if (it.kind === 'sum_type' || it.kind === 'product_type') {
+        chunk.push(it)
+        continue
+      }
+      into.push({
+        code: 'E1113',
+        message: diag.e1113InvalidJsSailJSDoc(),
+        offset: 0,
+        line: 1,
+        column: 1
+      })
+      skip = true
+      break
+    }
+    if (skip) continue
+    for (const it of chunk) {
+      if (it.kind === 'word') seenW.add(it.name)
+      items.push(it)
+    }
+  }
+  return { kind: 'source_file', items, span: dummySpan }
+}
+
+function buildTypeIndex (items) {
+  const m = new Map()
+  for (const it of items) {
+    if (it.kind === 'sum_type' || it.kind === 'product_type') {
+      m.set(it.name, it)
+    }
+  }
+  return m
+}
+
+/**
+ * Скобочный реэкспорт: символы в exportWords / exportTypes и копия ADT в typeIndex (RFC-0.1 §4.2).
+ */
+function mergeBracketReexports (importerPath, items, exportWords, exportTypes, typeIndex, ctx) {
+  for (const item of items) {
+    if (item.kind !== 'import' || !item.bracket) continue
+    const r = resolveImportPath(importerPath, item.path, ctx.readFile, ctx.resolvePackage)
+    if (!r.resolvedPath) continue
+    const dep = ctx.snapshots.get(r.resolvedPath)
+    if (!dep?.ok) continue
+    for (const w of item.bracket.words) {
+      if (dep.exportWords.has(w)) exportWords.add(w)
+    }
+    for (const ty of item.bracket.types) {
+      if (dep.exportTypes.has(ty)) {
+        exportTypes.add(ty)
+        if (!typeIndex.has(ty) && dep.typeIndex?.has(ty)) {
+          typeIndex.set(ty, dep.typeIndex.get(ty))
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @param {object} ctx
+ * @param {string} absPath
+ */
+function loadSnapshot (ctx, absPath) {
+  if (ctx.snapshots.has(absPath)) return ctx.snapshots.get(absPath)
+
+  if (ctx.loadingStack.includes(absPath)) {
+    const i = ctx.loadingStack.indexOf(absPath)
+    ctx.cycleModulesLabel = ctx.loadingStack.slice(i).map(p => path.basename(p)).join(', ')
+    return { error: 'cycle', path: absPath }
+  }
+
+  ctx.loadingStack.push(absPath)
+
+  const text = ctx.readFile(absPath)
+  if (text == null || text === undefined) {
+    ctx.loadingStack.pop()
+    const err = { error: 'missing', path: absPath }
+    ctx.snapshots.set(absPath, err)
+    return err
+  }
+
+  let ast
+  const parseDiags = []
+  if (absPath.endsWith('.js')) {
+    ast = parseJsContractAst(text, parseDiags)
+  } else {
+    const pr = parseSource(text)
+    if (!pr.ok) {
+      ctx.loadingStack.pop()
+      const err = { error: 'parse', diagnostics: pr.diagnostics, path: absPath }
+      ctx.snapshots.set(absPath, err)
+      return err
+    }
+    ast = pr.ast
+  }
+
+  const items = ast.items
+  const { diagnostics: declDiags, exportWords: ew0, exportTypes: et0 } = analyzeLocalDeclarations(items)
+  const typeIndex0 = buildTypeIndex(items)
+  const exportWords = new Set(ew0)
+  const exportTypes = new Set(et0)
+  const typeIndex = new Map(typeIndex0)
+  const allDeclDiags = [...parseDiags, ...declDiags]
+
+  for (const item of items) {
+    if (item.kind !== 'import') continue
+    const r = resolveImportPath(absPath, item.path, ctx.readFile, ctx.resolvePackage)
+    if (r.resolvedPath) {
+      const dep = loadSnapshot(ctx, r.resolvedPath)
+      if (dep?.error === 'cycle') {
+        ctx.loadingStack.pop()
+        const err = { error: 'cycle', path: absPath }
+        ctx.snapshots.set(absPath, err)
+        return err
+      }
+    }
+  }
+
+  ctx.loadingStack.pop()
+
+  mergeBracketReexports(absPath, items, exportWords, exportTypes, typeIndex, ctx)
+
+  const snap = {
+    ok: true,
+    path: absPath,
+    ast,
+    items,
+    declDiagnostics: allDeclDiags,
+    exportWords,
+    exportTypes,
+    typeIndex
+  }
+  ctx.snapshots.set(absPath, snap)
+  return snap
+}
+
+/**
+ * @param {object} snap
+ * @param {{ unq: Set<string>, importMap: Map<string, object> }} scope
+ * @param {object[]} out
+ */
+function resolveUseSitesInSnapshot (snap, scope, out) {
+  for (const item of snap.items) {
+    if (item.kind !== 'word') continue
+    walkWordDecl(item, (ev) => {
+      if (ev.kind === 'builtin_ref') {
+        const n = ev.node.name
+        if (!isBuiltinWord(n)) {
+          pushDiag(out, ev.node.span, 'E1206', diag.e1206UnknownBuiltin(n))
+        }
+        return
+      }
+      if (ev.kind === 'word_ref') {
+        const n = ev.node.name
+        if (scope.unq.has(n)) return
+        const mods = []
+        for (const [alias, dep] of scope.importMap) {
+          if (moduleExportsWord(dep, n)) mods.push(alias)
+        }
+        if (mods.length === 0) {
+          pushDiag(out, ev.node.span, 'E1201', diag.e1201UnresolvedName(n))
+        } else if (mods.length === 1) {
+          pushDiag(out, ev.node.span, 'E1205', diag.e1205ImportNeedsQualification(n, mods[0]))
+        } else {
+          pushDiag(out, ev.node.span, 'E1202', diag.e1202AmbiguousName(n))
+        }
+        return
+      }
+      if (ev.kind === 'module_word_ref') {
+        const { module: m, word: w } = ev.node
+        const dep = scope.importMap.get(m)
+        if (!dep) {
+          pushDiag(out, ev.node.span, 'E1203', diag.e1203ModuleNotFound(m))
+        } else if (!moduleExportsWord(dep, w)) {
+          pushDiag(out, ev.node.span, 'E1204', diag.e1204MissingMember(m, w))
+        }
+        return
+      }
+      if (ev.kind === 'module_type_ref') {
+        const { module: m, type: ty } = ev.node
+        const dep = scope.importMap.get(m)
+        if (!dep) {
+          pushDiag(out, ev.node.span, 'E1203', diag.e1203ModuleNotFound(m))
+        } else if (!dep.exportTypes.has(ty)) {
+          pushDiag(out, ev.node.span, 'E1204', diag.e1204MissingMember(m, ty))
+        }
+      }
+    })
+  }
+}
+
+/**
+ * @param {Map<string, object>} snapshots
+ */
+function buildSymbolTablesMap (snapshots) {
+  const m = new Map()
+  for (const [p, s] of snapshots) {
+    if (s && s.ok && s.exportWords) {
+      m.set(p, {
+        path: p,
+        words: [...s.exportWords].sort(),
+        types: [...s.exportTypes].sort()
+      })
+    }
+  }
+  return m
+}
+
+/**
+ * symbol_tables: путь → { words, types }. words — только `@` и реэкспорт `@` из скобок; types — локальные `&` и реэкспорт `&`.
+ * Имена autogen не перечисляются в words; `~M/w` для autogen учитывается через экспортируемые типы и typeIndex.
+ *
+ * @param {{ entryPath: string, readFile: (p: string) => string | null | undefined, resolvePackage?: (spec: string, fromPath: string) => string | null, withSnapshots?: boolean }} opts
+ * @returns {{ ok: boolean, diagnostics: object[], symbolTables?: Map<string, { path: string, words: string[], types: string[] }>, snapshots?: Map<string, object> }}
+ */
+export function resolveSailNames (opts) {
+  const readFile = opts.readFile
+  const entryPath = path.normalize(opts.entryPath)
+  const ctx = {
+    readFile,
+    resolvePackage: opts.resolvePackage,
+    snapshots: new Map(),
+    loadingStack: [],
+    cycleModulesLabel: null
+  }
+
+  const entrySnap = loadSnapshot(ctx, entryPath)
+
+  if (ctx.cycleModulesLabel || entrySnap?.error === 'cycle') {
+    const label = ctx.cycleModulesLabel || path.basename(entryPath)
+    return {
+      ok: false,
+      diagnostics: [{
+        code: 'E1112',
+        message: diag.e1112CyclicSailImports(label)
+      }],
+      symbolTables: buildSymbolTablesMap(ctx.snapshots)
+    }
+  }
+
+  if (entrySnap?.error === 'missing') {
+    return {
+      ok: false,
+      diagnostics: [{
+        code: 'E1203',
+        message: diag.e1203ModuleNotFound(path.basename(entryPath, path.extname(entryPath)))
+      }],
+      symbolTables: buildSymbolTablesMap(ctx.snapshots)
+    }
+  }
+
+  if (entrySnap?.error === 'parse') {
+    return {
+      ok: false,
+      diagnostics: entrySnap.diagnostics ?? [{ code: 'E1001', message: 'parse failed' }],
+      symbolTables: buildSymbolTablesMap(ctx.snapshots)
+    }
+  }
+
+  if (!entrySnap || entrySnap.ok !== true) {
+    return {
+      ok: false,
+      diagnostics: [{ code: 'E1203', message: diag.e1203ModuleNotFound('entry') }],
+      symbolTables: buildSymbolTablesMap(ctx.snapshots)
+    }
+  }
+
+  const allDiags = []
+  for (const [, s] of ctx.snapshots) {
+    if (s?.ok && Array.isArray(s.declDiagnostics)) {
+      allDiags.push(...s.declDiagnostics)
+    }
+  }
+
+  for (const [, s] of ctx.snapshots) {
+    if (!s?.ok) continue
+    const scope = buildScopeForSnapshot(s, ctx)
+    allDiags.push(...scope.diags)
+    resolveUseSitesInSnapshot(s, scope, allDiags)
+  }
+
+  const ok = allDiags.length === 0
+  /** @type {{ ok: boolean, diagnostics: object[], symbolTables: Map<string, { path: string, words: string[], types: string[] }>, snapshots?: Map<string, object> }} */
+  const out = {
+    ok,
+    diagnostics: allDiags,
+    symbolTables: buildSymbolTablesMap(ctx.snapshots)
+  }
+  if (opts.withSnapshots) {
+    out.snapshots = ctx.snapshots
+  }
+  return out
+}

package/lib/names/walk-ast-refs.js

@@ -0,0 +1,91 @@
+/**
+ * Обход use-sites для L2: word_ref, module_word_ref, module_type_ref (RFC-0.1 §11).
+ */
+
+/** @param {object} typeExpr */
+export function walkTypeExpr (typeExpr, visit) {
+  if (!typeExpr) return
+  switch (typeExpr.kind) {
+    case 'type_name':
+    case 'type_var':
+      return
+    case 'module_type_ref':
+      visit({ kind: 'module_type_ref', node: typeExpr })
+      return
+    case 'paren_type':
+      walkTypeExpr(typeExpr.inner, visit)
+      return
+    case 'type_app':
+      for (const a of typeExpr.args) walkTypeExpr(a, visit)
+      return
+    case 'quotation_type':
+      walkSignature(typeExpr.inner, visit)
+      return
+    default:
+      return
+  }
+}
+
+/** @param {object} item AstSigStackItem */
+export function walkSigStackItem (item, visit) {
+  if (!item) return
+  switch (item.kind) {
+    case 'sig_type_expr':
+      walkTypeExpr(item.type, visit)
+      return
+    case 'quotation_sig':
+      walkSignature(item.inner, visit)
+      return
+    case 'named_quotation_sig':
+      walkSigStackItem(item.quotation, visit)
+      return
+    case 'stack_var':
+    case 'sig_effect_add':
+    case 'sig_effect_remove':
+      return
+    default:
+      return
+  }
+}
+
+/** @param {object} sig AstSignature */
+export function walkSignature (sig, visit) {
+  if (!sig) return
+  for (const x of sig.left) walkSigStackItem(x, visit)
+  for (const x of sig.right) walkSigStackItem(x, visit)
+}
+
+/** @param {object[]} steps AstWordStep[] */
+export function walkWordSteps (steps, visit) {
+  if (!steps) return
+  for (const step of steps) {
+    switch (step.kind) {
+      case 'word_ref':
+        visit({ kind: 'word_ref', node: step })
+        break
+      case 'module_word_ref':
+        visit({ kind: 'module_word_ref', node: step })
+        break
+      case 'builtin':
+        visit({ kind: 'builtin_ref', node: step })
+        break
+      case 'literal':
+      case 'slot_write':
+      case 'slot_read':
+        break
+      case 'quotation':
+        walkWordSteps(step.body, visit)
+        break
+      case 'list_literal':
+        break
+      default:
+        break
+    }
+  }
+}
+
+/** @param {object} word AstWord */
+export function walkWordDecl (word, visit) {
+  walkSignature(word.signature, visit)
+  walkWordSteps(word.body, visit)
+}

package/lib/parse/ast-build.js

@@ -0,0 +1,51 @@
+/**
+ * AST node factories (RFC-0.1 §12.2). No classes — plain objects.
+ */
+
+/** @param {{ offset: number, line: number, column: number }} t */
+export function posFromToken (t) {
+  return { offset: t.offset, line: t.line, column: t.column }
+}
+
+export function endPosFromState (state) {
+  return { offset: state.i, line: state.line, column: state.col }
+}
+
+export function openSpan (tok) {
+  return {
+    start: posFromToken(tok),
+    end: { offset: tok.offset, line: tok.line, column: tok.column }
+  }
+}
+
+export function closeSpan (state, span) {
+  span.end = endPosFromState(state)
+  return span
+}
+
+export function spanRange (state, startTok) {
+  return closeSpan(state, openSpan(startTok))
+}
+
+export function spanCoords (state, startOff, startLine, startCol) {
+  return {
+    start: { offset: startOff, line: startLine, column: startCol },
+    end: endPosFromState(state)
+  }
+}
+
+/**
+ * @param {string} kind
+ * @param {{ start: object, end: object }} span
+ * @param {Record<string, unknown>} fields
+ */
+export function node (kind, span, fields) {
+  return { kind, span, ...fields }
+}
+
+export function mergeSpan (spanA, spanB) {
+  return {
+    start: spanA.start,
+    end: spanB.end
+  }
+}