@algosail/lang 0.2.12 → 0.5.1

package/lib/ir/serialize.js

@@ -0,0 +1,202 @@
+/**
+ * Модель сериализации IR для JSON (RFC-IR-0.1 §8: on-disk формат не обязателен;
+ * при публикации — рекомендуется irSchemaVersion).
+ *
+ * Конверт стабилен; внутренний объект `module` — единственный источник правды по шагам
+ * и стеку (RFC-IR §3). Поля `views` / `meta` опциональны: лёгкие проекции и метаданные
+ * продьюсера. LSP/дебаг читают типы и вложенные quotation из
+ * `module` через обёртки в коде, не дублируя `preTypes`/`postTypes` во `views`.
+ *
+ * Ограничения: только JSON-safe значения; см. [assert-json-serializable.js](./assert-json-serializable.js).
+ *
+ * ---
+ * Договорённости wire (фаза 0; наполнение модуля — фазы 1+):
+ *
+ * **`nodeId`** / **`span`** на шагах тела: после фазы 2 задаются на элементах `words[].irSteps`
+ * ([lower-body-steps.js](./lower-body-steps.js)); формат id — `"{modulePath}#{wordName}#{индексы}"`
+ * (вложение quotation — индексы через `.`, напр. `…#0.1`). В `words[].stackSteps.steps[]` элемент `i`
+ * — снимок шага `i` или `null`; те же `preTypes`/`postTypes` после фазы 3 дублируются на `irSteps[i]`.
+ *
+ * **`span`** — происхождение в `.sail`, как у парсера. Для LSP позже: позиции в UTF-16 code units.
+ * @typedef {{ start: { offset: number, line: number, column: number }, end?: { offset: number, line: number, column: number } }} IrWireSpan
+ *
+ * **`preTypes` / `postTypes`** — массивы типовых слотов **дно → вершина** (в `stackSteps` и после фазы 3 на узлах тела; RFC-IR §3).
+ *
+ * **`valueBindings`** (фаза 4, опционально): `argIds` — id, снимаемые для эффекта шага (**последний — вершина** до шага);
+ * `resultIds` — id после шага (**дно → вершина**, как `postTypes`). Для `dup` два элемента `resultIds` — одна и та же строка id.
+ *
+ * **Эффекты (фаза 5, RFC-IR §6):** на записи `words[]` — булевы **`asyncDefinition`**, **`mayFail`** (явные `false`, если эффекта нет);
+ * на узлах вызова в `irSteps` (и вложенных шагах) опционально **`calleeAsync`**, **`calleeMayFail`** ([attach-call-effects.js](./attach-call-effects.js)).
+ *
+ * **Модуль (фаза 6, RFC-IR §7):** в `imports[]` опционально **`resolvedPath`** — нормализованный путь зависимости (как в `scopeByPath.importMap` после L2);
+ * на узле **`Word`** с `ref: "qualified"` опционально **`resolvedModulePath`** для того же алиаса `module` ([module-metadata.js](./module-metadata.js)).
+ *
+ * **Quotation на стеке** (типовой слот): узел с `kind: "quote" | "named_quote"`, при named —
+ * `prefix`, поле `inner` — нормализованная сигнатура (wire без AST). Полный контур шагов с
+ * `nodeId`/`span`/`preTypes`/`postTypes` на вложенных шагах — цель фаз 2–3 в `module`.
+ *
+ * @typedef {{ name: string, version?: string }} IrWireProducer
+ * @typedef {{
+ *   producer?: IrWireProducer,
+ *   sources?: { path?: string, uri?: string, sha256?: string }[],
+ *   status?: 'ok' | 'error'
+ * }} IrWireMeta итог L3 по модулю (RFC-IR-0.1 §1.1); задаётся продьюсером IR, не выводится из `module` автоматически.
+ * @typedef {Record<string, unknown>} IrWireViews — тонкие проекции (индексы nodeId и т.д.), без дубликата стека.
+ */
+
+import { IR_SCHEMA_VERSION } from './schema-version.js'
+
+/**
+ * @typedef {Record<string, unknown>} IrModulePayload — тело IR модуля; по мере фаз расширяется.
+ * `words[]`: `stackSteps.steps[i]` — снимок шага `i` или `null` (выравнивание с телом); `irSteps[i]` — узел section 5
+ * с `nodeId`/`span` и после фазы 3 теми же `preTypes`/`postTypes`, что у снимка ([stitch-types.js](./stitch-types.js));
+ * после фазы 4 опционально `valueBindings` на узле шага ([bind-values.js](./bind-values.js));
+ * после фазы 5 — `asyncDefinition`/`mayFail` на записи слова и `calleeAsync`/`calleeMayFail` на шагах вызова ([attach-call-effects.js](./attach-call-effects.js));
+ * после фазы 6 — `imports[].resolvedPath`, на квалифицированном `Word` — `resolvedModulePath` ([module-metadata.js](./module-metadata.js)).
+ */
+
+/**
+ * Корень документа при передаче/хранении в JSON.
+ *
+ * @typedef {{
+ *   irSchemaVersion: string
+ *   module: IrModulePayload
+ *   views?: IrWireViews
+ *   meta?: IrWireMeta
+ * }} SerializedIrDocument
+ */
+
+/**
+ * Результат полного разбора корня (игнорируются неизвестные дополнительные ключи).
+ *
+ * @typedef {{
+ *   module: IrModulePayload
+ *   views?: IrWireViews
+ *   meta?: IrWireMeta
+ * }} ParsedIrDocument
+ */
+
+const KEY_VERSION = 'irSchemaVersion'
+const KEY_MODULE = 'module'
+const KEY_VIEWS = 'views'
+const KEY_META = 'meta'
+
+/**
+ * @param {unknown} parsed
+ * @returns {ParsedIrDocument}
+ */
+function parseDocumentRoot (parsed) {
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('IR JSON: ожидался объект корня документа')
+  }
+  const o = /** @type {Record<string, unknown>} */ (parsed)
+  const ver = o[KEY_VERSION]
+  if (ver !== IR_SCHEMA_VERSION) {
+    throw new Error(
+      `IR JSON: неподдерживаемая irSchemaVersion ${JSON.stringify(ver)} (ожидается ${IR_SCHEMA_VERSION})`
+    )
+  }
+  const mod = o[KEY_MODULE]
+  if (mod === null || typeof mod !== 'object' || Array.isArray(mod)) {
+    throw new Error('IR JSON: поле module должно быть объектом')
+  }
+
+  let views = undefined
+  if (Object.prototype.hasOwnProperty.call(o, KEY_VIEWS)) {
+    const v = o[KEY_VIEWS]
+    if (v != null && (typeof v !== 'object' || Array.isArray(v))) {
+      throw new Error('IR JSON: поле views должно быть объектом')
+    }
+    if (v != null) {
+      views = /** @type {IrWireViews} */ (v)
+    }
+  }
+
+  let meta = undefined
+  if (Object.prototype.hasOwnProperty.call(o, KEY_META)) {
+    const m = o[KEY_META]
+    if (m != null && (typeof m !== 'object' || Array.isArray(m))) {
+      throw new Error('IR JSON: поле meta должно быть объектом')
+    }
+    if (m != null) {
+      meta = /** @type {IrWireMeta} */ (m)
+    }
+  }
+
+  return {
+    module: /** @type {IrModulePayload} */ (mod),
+    views,
+    meta
+  }
+}
+
+/**
+ * @param {IrModulePayload} modulePayload
+ * @param {{ views?: IrWireViews, meta?: IrWireMeta }} [options]
+ * @returns {SerializedIrDocument}
+ */
+export function createSerializedIrDocument (modulePayload, options) {
+  const doc = /** @type {SerializedIrDocument} */ ({
+    [KEY_VERSION]: IR_SCHEMA_VERSION,
+    [KEY_MODULE]: modulePayload
+  })
+  if (options?.views != null) {
+    if (typeof options.views !== 'object' || Array.isArray(options.views)) {
+      throw new Error('IR JSON: options.views должно быть объектом')
+    }
+    doc[KEY_VIEWS] = options.views
+  }
+  if (options?.meta != null) {
+    if (typeof options.meta !== 'object' || Array.isArray(options.meta)) {
+      throw new Error('IR JSON: options.meta должно быть объектом')
+    }
+    doc[KEY_META] = options.meta
+  }
+  return doc
+}
+
+/**
+ * Достаёт `module` из уже распарсенного JSON-объекта; проверяет версию.
+ * Неизвестные ключи на корне допустимы и игнорируются.
+ *
+ * @param {unknown} parsed
+ * @returns {IrModulePayload}
+ */
+export function unwrapSerializedIrDocument (parsed) {
+  return parseDocumentRoot(parsed).module
+}
+
+/**
+ * Полный разбор корня: `module`, опционально `views` и `meta`.
+ *
+ * @param {unknown} parsed
+ * @returns {ParsedIrDocument}
+ */
+export function unwrapSerializedIrDocumentFull (parsed) {
+  return parseDocumentRoot(parsed)
+}
+
+/**
+ * @param {IrModulePayload} modulePayload
+ * @param {{ views?: IrWireViews, meta?: IrWireMeta }} [options]
+ * @returns {string}
+ */
+export function stringifyIrDocument (modulePayload, options) {
+  return JSON.stringify(createSerializedIrDocument(modulePayload, options))
+}
+
+/**
+ * @param {string} jsonText
+ * @returns {IrModulePayload}
+ */
+export function parseIrDocument (jsonText) {
+  return unwrapSerializedIrDocument(JSON.parse(jsonText))
+}
+
+/**
+ * @param {string} jsonText
+ * @returns {ParsedIrDocument}
+ */
+export function parseIrDocumentFull (jsonText) {
+  return unwrapSerializedIrDocumentFull(JSON.parse(jsonText))
+}

package/lib/ir/stitch-types.js

@@ -0,0 +1,92 @@
+/**
+ * L4 фаза 3: стыковка снимков L3 с `irSteps` (RFC-IR section 3).
+ * Переиспользует {@link verifySnapshotChainStitches} из typecheck без второго вывода типов.
+ */
+import { verifySnapshotChainStitches } from '../typecheck/stack-step-snapshots.js'
+
+/**
+ * @param {unknown} v
+ * @returns {unknown}
+ */
+function cloneJsonSafe (v) {
+  return JSON.parse(JSON.stringify(v))
+}
+
+/**
+ * Wire `stackSteps` (как из `build-module-ir` после конвертации снимка L3) → форма `WordStackSnapshotRecord`.
+ *
+ * @param {{ steps?: unknown[], nestedByParentStep?: { parentStepIndex: number, record: object }[] }} wire
+ * @returns {{ steps: object[], nestedByParentStep: Map<number, object> }}
+ */
+export function wireStackSnapshotToRecord (wire) {
+  const wsteps = wire.steps ?? []
+  /** @type {object[]} */
+  const steps = []
+  for (let i = 0; i < wsteps.length; i++) {
+    const s = wsteps[i]
+    if (s == null || typeof s !== 'object') {
+      steps.push(null)
+      continue
+    }
+    const o = /** @type {Record<string, unknown>} */ (s)
+    const preTypes = o.preTypes
+    const postTypes = o.postTypes
+    steps.push({
+      pre: Array.isArray(preTypes) ? preTypes : [],
+      post: postTypes !== undefined ? postTypes : undefined
+    })
+  }
+  const nested = new Map()
+  for (const e of wire.nestedByParentStep ?? []) {
+    nested.set(e.parentStepIndex, wireStackSnapshotToRecord(e.record))
+  }
+  return { steps, nestedByParentStep: nested }
+}
+
+/**
+ * @param {{ steps?: unknown[], nestedByParentStep?: unknown[] }} wire
+ * @returns {boolean}
+ */
+export function verifyWireStackSnapshot (wire) {
+  if (wire == null || typeof wire !== 'object') return false
+  return verifySnapshotChainStitches(wireStackSnapshotToRecord(wire))
+}
+
+/**
+ * Копирует `preTypes`/`postTypes` с `wireStack.steps[i]` на `irSteps[i]`; для `Quotation` — рекурсия по `nestedByParentStep`.
+ *
+ * @param {Record<string, unknown>[]} irSteps
+ * @param {{ steps?: unknown[], nestedByParentStep?: { parentStepIndex: number, record: object }[] }} wireStack
+ */
+export function attachStackTypesToIrSteps (irSteps, wireStack) {
+  if (!Array.isArray(irSteps) || wireStack == null || typeof wireStack !== 'object') {
+    return
+  }
+  const wsteps = wireStack.steps
+  if (!Array.isArray(wsteps)) return
+
+  const nestedArr = wireStack.nestedByParentStep ?? []
+
+  for (let i = 0; i < irSteps.length; i++) {
+    const node = irSteps[i]
+    if (node == null || typeof node !== 'object') continue
+    const w = i < wsteps.length ? wsteps[i] : undefined
+    if (w == null || typeof w !== 'object') continue
+    const slot = /** @type {Record<string, unknown>} */ (w)
+    if (Array.isArray(slot.preTypes)) {
+      node.preTypes = cloneJsonSafe(slot.preTypes)
+    }
+    if (slot.postTypes !== undefined) {
+      node.postTypes = cloneJsonSafe(slot.postTypes)
+    }
+    if (node.kind === 'Quotation' && Array.isArray(node.steps)) {
+      const nestedEntry = nestedArr.find((e) => e.parentStepIndex === i)
+      if (nestedEntry?.record != null) {
+        attachStackTypesToIrSteps(
+          /** @type {Record<string, unknown>[]} */ (node.steps),
+          nestedEntry.record
+        )
+      }
+    }
+  }
+}

package/lib/names/adt-autogen.js

@@ -0,0 +1,22 @@
+import { lowerFirst } from './lower-first.js'
+
+/** @param {{ name: string }[]} tags */
+export function autogenWordNamesForSumType (typeName, tags) {
+  const out = new Set()
+  for (const tag of tags) {
+    out.add(lowerFirst(tag.name))
+  }
+  out.add(lowerFirst(typeName))
+  return out
+}
+
+/** @param {{ name: string }[]} fields */
+export function autogenWordNamesForProductType (typeName, fields) {
+  const out = new Set()
+  out.add(lowerFirst(typeName))
+  for (const f of fields) {
+    out.add(lowerFirst(f.name + typeName))
+  }
+  out.add(lowerFirst('with' + typeName))
+  return out
+}

package/lib/names/import-path.js

@@ -0,0 +1,28 @@
+/**
+ * Разрешение строки импорта в абсолютный путь (RFC-0.1 §4.2).
+ */
+import path from 'node:path'
+
+/**
+ * @param {string} importerPath
+ * @param {string} spec
+ * @param {(p: string) => string | null | undefined} readFile
+ * @param {((spec: string, fromPath: string) => string | null) | undefined} resolvePackage
+ * @returns {{ resolvedPath: string | null, missing: boolean }}
+ */
+export function resolveImportPath (importerPath, spec, readFile, resolvePackage) {
+  if (spec.startsWith('./') || spec.startsWith('../')) {
+    const resolved = path.normalize(path.join(path.dirname(importerPath), spec))
+    const t = readFile(resolved)
+    if (t == null || t === undefined) return { resolvedPath: null, missing: true }
+    return { resolvedPath: resolved, missing: false }
+  }
+  if (resolvePackage) {
+    const resolved = resolvePackage(spec, importerPath)
+    if (!resolved) return { resolvedPath: null, missing: true }
+    const t = readFile(resolved)
+    if (t == null || t === undefined) return { resolvedPath: null, missing: true }
+    return { resolvedPath: resolved, missing: false }
+  }
+  return { resolvedPath: null, missing: true }
+}

package/lib/names/index.js

@@ -0,0 +1 @@
+export { resolveSailNames } from './resolve-sail.js'

package/lib/names/local-declarations.js

@@ -0,0 +1,127 @@
+/**
+ * Локальные декларации в одном source_file: E1101–E1105, E1108, E1111; экспорт слов/типов (RFC-0.1 §4, §7).
+ */
+import * as diag from '../parse/diagnostics.js'
+import { autogenWordNamesForProductType, autogenWordNamesForSumType } from './adt-autogen.js'
+
+/**
+ * @param {object[]} items AstTopLevel[]
+ * exportWords — только `@word`; autogen ADT не входит (RFC L2). exportTypes — имена `&`.
+ * @returns {{ diagnostics: object[], exportWords: Set<string>, exportTypes: Set<string> }}
+ */
+export function analyzeLocalDeclarations (items) {
+  const diagnostics = []
+  /** @type {Map<string, object>} */
+  const firstWordSpan = new Map()
+  /** @type {Map<string, object>} */
+  const firstTypeSpan = new Map()
+  /** @type {Map<string, object>} */
+  const globalTagSpan = new Map()
+
+  const exportWords = new Set()
+  const exportTypes = new Set()
+  /** Имена autogen в модуле (не входят в exportWords; нужны для E1105 между типами). */
+  const autogenUsed = new Set()
+  const seenImportModule = new Map()
+
+  function pushDiag (code, message, span) {
+    const d = { code, message }
+    if (span?.start) {
+      d.offset = span.start.offset
+      d.line = span.start.line
+      d.column = span.start.column
+    }
+    diagnostics.push(d)
+  }
+
+  for (const item of items) {
+    if (item.kind === 'import') {
+      if (seenImportModule.has(item.module)) {
+        pushDiag('E1111', diag.e1111DuplicateModuleImport(item.module), item.span)
+      } else {
+        seenImportModule.set(item.module, item.span)
+      }
+      if (item.bracket) {
+        const seenInBracket = new Set()
+        for (const w of item.bracket.words) {
+          if (seenInBracket.has(w)) {
+            pushDiag('E1108', diag.e1108DuplicateBracketImportName(w), item.span)
+          }
+          seenInBracket.add(w)
+        }
+        for (const ty of item.bracket.types) {
+          if (seenInBracket.has(ty)) {
+            pushDiag('E1108', diag.e1108DuplicateBracketImportName(ty), item.span)
+          }
+          seenInBracket.add(ty)
+        }
+      }
+      continue
+    }
+
+    if (item.kind === 'word') {
+      if (firstWordSpan.has(item.name)) {
+        pushDiag('E1101', diag.e1101DuplicateWord(item.name), item.span)
+      } else {
+        if (autogenUsed.has(item.name)) {
+          pushDiag('E1105', diag.e1105AutogenNameConflict(item.name), item.span)
+        }
+        firstWordSpan.set(item.name, item.span)
+        exportWords.add(item.name)
+      }
+      continue
+    }
+
+    if (item.kind === 'sum_type') {
+      if (firstTypeSpan.has(item.name)) {
+        pushDiag('E1102', diag.e1102DuplicateType(item.name), item.span)
+      } else {
+        firstTypeSpan.set(item.name, item.span)
+        exportTypes.add(item.name)
+      }
+      for (const tag of item.tags) {
+        if (globalTagSpan.has(tag.name)) {
+          pushDiag('E1103', diag.e1103DuplicateSumTag(tag.name), tag.span)
+        } else {
+          globalTagSpan.set(tag.name, tag.span)
+        }
+      }
+      const auto = autogenWordNamesForSumType(item.name, item.tags)
+      for (const w of auto) {
+        if (exportWords.has(w) || autogenUsed.has(w)) {
+          pushDiag('E1105', diag.e1105AutogenNameConflict(w), item.span)
+        } else {
+          autogenUsed.add(w)
+        }
+      }
+      continue
+    }
+
+    if (item.kind === 'product_type') {
+      if (firstTypeSpan.has(item.name)) {
+        pushDiag('E1102', diag.e1102DuplicateType(item.name), item.span)
+      } else {
+        firstTypeSpan.set(item.name, item.span)
+        exportTypes.add(item.name)
+      }
+      const fieldSeen = new Map()
+      for (const f of item.fields) {
+        if (fieldSeen.has(f.name)) {
+          pushDiag('E1104', diag.e1104DuplicateProductField(f.name, item.name), f.span)
+        } else {
+          fieldSeen.set(f.name, f.span)
+        }
+      }
+      const auto = autogenWordNamesForProductType(item.name, item.fields)
+      for (const w of auto) {
+        if (exportWords.has(w) || autogenUsed.has(w)) {
+          pushDiag('E1105', diag.e1105AutogenNameConflict(w), item.span)
+        } else {
+          autogenUsed.add(w)
+        }
+      }
+    }
+  }
+
+  return { diagnostics, exportWords, exportTypes }
+}

package/lib/names/lower-first.js

@@ -0,0 +1,6 @@
+/** RFC-0.1 §7.1.2 / §7.2.1 — lower-first для автоген-имён. */
+
+export function lowerFirst (s) {
+  if (s == null || s.length === 0) return s
+  return s[0].toLowerCase() + s.slice(1)
+}

package/lib/names/module-scope.js

@@ -0,0 +1,120 @@
+/**
+ * Область импорта модуля для L2/L3: unq, importMap (RFC-0.1 §4.2, §9).
+ */
+import * as diag from '../parse/diagnostics.js'
+import { autogenWordNamesForProductType, autogenWordNamesForSumType } from './adt-autogen.js'
+import { resolveImportPath } from './import-path.js'
+
+/**
+ * @param {object} item
+ * @returns {Set<string>}
+ */
+export function typeAutogenWords (item) {
+  if (item.kind === 'sum_type') {
+    return autogenWordNamesForSumType(item.name, item.tags)
+  }
+  if (item.kind === 'product_type') {
+    return autogenWordNamesForProductType(item.name, item.fields)
+  }
+  return new Set()
+}
+
+/** Слово доступно как `~Module/name`: явный экспорт или autogen экспортируемого типа. */
+export function moduleExportsWord (dep, name) {
+  if (dep.exportWords.has(name)) return true
+  for (const ty of dep.exportTypes) {
+    const def = dep.typeIndex.get(ty)
+    if (!def) continue
+    if (typeAutogenWords(def).has(name)) return true
+  }
+  return false
+}
+
+/**
+ * @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 {object} snap
+ * @param {{ readFile: (p: string) => string | null | undefined, resolvePackage?: (spec: string, fromPath: string) => string | null, snapshots: Map<string, object> }} ctx
+ * @returns {{ unq: Set<string>, importMap: Map<string, object>, diags: object[] }}
+ */
+export function buildScopeForSnapshot (snap, ctx) {
+  const diags = []
+  const unq = new Set()
+  const localTypes = new Set()
+  /** @type {Map<string, object>} */
+  const importMap = new Map()
+
+  for (const item of snap.items) {
+    if (item.kind === 'word') {
+      unq.add(item.name)
+      continue
+    }
+    if (item.kind === 'sum_type') {
+      localTypes.add(item.name)
+      for (const w of autogenWordNamesForSumType(item.name, item.tags)) unq.add(w)
+      continue
+    }
+    if (item.kind === 'product_type') {
+      localTypes.add(item.name)
+      for (const w of autogenWordNamesForProductType(item.name, item.fields)) unq.add(w)
+      continue
+    }
+    if (item.kind === 'import') {
+      const r = resolveImportPath(snap.path, item.path, ctx.readFile, ctx.resolvePackage)
+      const dep = r.resolvedPath ? ctx.snapshots.get(r.resolvedPath) : null
+      const usable = dep && dep.ok === true
+
+      if (!usable) {
+        pushDiag(diags, item.span, 'E1203', diag.e1203ModuleNotFound(item.module))
+        continue
+      }
+
+      importMap.set(item.module, dep)
+
+      if (item.bracket) {
+        for (const w of item.bracket.words) {
+          if (!dep.exportWords.has(w)) {
+            pushDiag(diags, item.span, 'E1110', diag.e1110SymbolMissingInExport(w))
+          }
+          if (unq.has(w)) {
+            pushDiag(diags, item.span, 'E1109', diag.e1109BracketImportConflicts(w))
+          }
+          unq.add(w)
+        }
+        for (const ty of item.bracket.types) {
+          if (!dep.exportTypes.has(ty)) {
+            pushDiag(diags, item.span, 'E1110', diag.e1110SymbolMissingInExport(ty))
+          }
+          if (localTypes.has(ty)) {
+            pushDiag(diags, item.span, 'E1109', diag.e1109BracketImportConflicts(ty))
+          }
+          localTypes.add(ty)
+          const def = dep.typeIndex.get(ty)
+          if (def) {
+            for (const aw of typeAutogenWords(def)) {
+              if (unq.has(aw)) {
+                pushDiag(diags, item.span, 'E1109', diag.e1109BracketImportConflicts(aw))
+              }
+              unq.add(aw)
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return { unq, importMap, diags }
+}