semantifold 0.3.0 → 0.4.0

package/src/backends/typescript.js

@@ -1,7 +1,7 @@
 // @ts-check
 
-import {emitExpression, requiresCanonicalZeroRendering} from "./shared.js"
-import {emitScalarType} from "./scalars.js"
+import {emitExpression, emitType, requiresCanonicalZeroRendering} from "./shared.js"
+import {emitEffectPrefixes, emitEffectSupport} from "./effects.js"
 
 /**
  * Emits an independently executable TypeScript program through the source-aware writer.
@@ -11,13 +11,62 @@ import {emitScalarType} from "./scalars.js"
  */
 export function generateTypeScript(module, writer) {
   const canonicalizeZero = requiresCanonicalZeroRendering(module)
+  const records = module.records ?? []
+  const classes = module.classes ?? []
+  const errors = module.errors ?? []
+
+  emitProgramImports(module, writer)
+  emitEffectSupport(writer, module, "typescript")
+
+  errors.forEach((error, errorIndex) => {
+    const path = `/errors/${errorIndex}`
+
+    if (errorIndex > 0) writer.synthetic("\n\n", "error declaration separator", [error], [path])
+    if (writer.isDirectlyExported(error.id)) writer.synthetic("export ", "ESM error export", [error], [path])
+    writer.mapped("class", {mappingKind: "anchor", node: error, path})
+    writer.synthetic(" ", "error declaration spacing", [error], [path])
+    writer.mapped(error.name, {mappingKind: "exact", node: error, path, role: "name"})
+    writer.synthetic(" extends Error {}", "TypeScript unchecked error scaffolding", [error], [path])
+  })
+  if (errors.length > 0) writer.synthetic("\n\n", "error/declaration separator", [module])
+
+  records.forEach((record, recordIndex) => {
+    const recordPath = `/records/${recordIndex}`
+
+    if (recordIndex > 0) writer.synthetic("\n\n", "record declaration separator", [record], [recordPath])
+    if (writer.isDirectlyExported(record.id)) writer.synthetic("export ", "ESM record export", [record], [recordPath])
+    writer.mapped("class", {mappingKind: "anchor", node: record, path: recordPath})
+    writer.synthetic(" ", "record declaration spacing", [record], [recordPath])
+    writer.mapped(record.name, {mappingKind: "exact", node: record, path: recordPath, role: "name"})
+    emitTypeParameters(writer, record.typeParameters ?? [], `${recordPath}/typeParameters`)
+    writer.synthetic(" {\n  constructor(", "TypeScript record constructor scaffolding", [record], [recordPath])
+    record.fields.forEach((field, fieldIndex) => {
+      const fieldPath = `${recordPath}/fields/${fieldIndex}`
+
+      if (fieldIndex) writer.synthetic(", ", "record field separator", [record], [recordPath])
+      writer.synthetic("readonly ", "TypeScript readonly field scaffolding", [field], [fieldPath])
+      writer.mapped(field.name, {mappingKind: "exact", node: field, path: fieldPath, role: "name"})
+      writer.synthetic(": ", "type separator", [field], [fieldPath])
+      emitType(writer, field.type, `${fieldPath}/type`, "typescript")
+    })
+    writer.synthetic(") {}\n}", "TypeScript record constructor scaffolding", [record], [recordPath])
+  })
+  if (records.length > 0) writer.synthetic("\n\n", "record/function separator", [module])
+
+  classes.forEach((declaration, classIndex) => {
+    if (classIndex > 0) writer.synthetic("\n\n", "reference class separator", [declaration], [`/classes/${classIndex}`])
+    emitReferenceClass(writer, declaration, classIndex, canonicalizeZero)
+  })
+  if (classes.length > 0) writer.synthetic("\n\n", "reference class/function separator", [module])
 
   module.functions.forEach((declaration, functionIndex) => {
     if (functionIndex > 0) writer.synthetic("\n\n", "declaration separator", [declaration])
 
+    if (writer.isDirectlyExported(declaration.id)) writer.synthetic("export ", "ESM function export", [declaration])
     writer.mapped("function", {mappingKind: "anchor", node: declaration})
     writer.synthetic(" ", "function spacing", [declaration])
     writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, role: "name"})
+    emitTypeParameters(writer, declaration.typeParameters ?? [], `/functions/${functionIndex}/typeParameters`)
     writer.mapped("(", {mappingKind: "anchor", node: declaration})
     declaration.parameters.forEach((parameter, index) => {
       const parameterPath = `/functions/${functionIndex}/parameters/${index}`
@@ -25,21 +74,11 @@ export function generateTypeScript(module, writer) {
       if (index > 0) writer.synthetic(", ", "parameter separator", [declaration])
       writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: parameterPath, role: "name"})
       writer.synthetic(": ", "type separator", [parameter], [parameterPath])
-      writer.mapped(emitScalarType("typescript", parameter.type), {
-        mappingKind: "exact",
-        node: parameter.type,
-        path: `${parameterPath}/type`,
-        role: "type"
-      })
+      emitType(writer, parameter.type, `${parameterPath}/type`, "typescript")
     })
     writer.mapped(")", {mappingKind: "anchor", node: declaration})
     writer.synthetic(": ", "return type separator", [declaration])
-    writer.mapped(emitScalarType("typescript", declaration.returnType), {
-      mappingKind: "exact",
-      node: declaration.returnType,
-      path: `/functions/${functionIndex}/returnType`,
-      role: "type"
-    })
+    emitType(writer, declaration.returnType, `/functions/${functionIndex}/returnType`, "typescript")
     writer.synthetic(" ", "function spacing", [declaration])
     writer.mapped("{", {mappingKind: "anchor", node: declaration})
     writer.synthetic("\n", "line break", [declaration])
@@ -48,8 +87,184 @@ export function generateTypeScript(module, writer) {
     writer.mapped("}", {mappingKind: "anchor", node: declaration})
   })
 
-  writer.synthetic("\n\n", "entry-point separator", [module.entryPoint])
-  emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body", canonicalizeZero)
+  emitAliasedExports(module, writer)
+  if (!writer.program || writer.isProgramEntry()) {
+    writer.synthetic("\n\n", "entry-point separator", [module.entryPoint])
+    emitBlock(writer, module.entryPoint.body, "", "/entryPoint/body", canonicalizeZero)
+  }
+}
+
+/**
+ * Emits one native TypeScript reference class.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").ClassDeclaration} declaration - Reference class.
+ * @param {number} classIndex - Module class index.
+ * @param {boolean} canonicalizeZero - Whether scalar output canonicalizes zero.
+ * @returns {void}
+ */
+function emitReferenceClass(writer, declaration, classIndex, canonicalizeZero) {
+  const path = `/classes/${classIndex}`
+
+  writer.mapped("class", {mappingKind: "anchor", node: declaration, path})
+  writer.synthetic(" ", "reference class spacing", [declaration], [path])
+  writer.mapped(declaration.name, {mappingKind: "exact", node: declaration, path, role: "name"})
+  writer.synthetic(" {\n", "reference class open", [declaration], [path])
+  declaration.fields.forEach((field, index) => {
+    const fieldPath = `${path}/fields/${index}`
+
+    writer.synthetic("  private ", "private field scaffolding", [field], [fieldPath])
+    writer.mapped(field.name, {mappingKind: "exact", node: field, path: fieldPath, role: "name"})
+    writer.synthetic(": ", "private field type separator", [field], [fieldPath])
+    emitType(writer, field.type, `${fieldPath}/type`, "typescript")
+    writer.synthetic("\n", "line break", [field], [fieldPath])
+  })
+  const constructor = declaration.constructor
+  const constructorPath = `${path}/constructor`
+
+  writer.synthetic("\n  ", "constructor spacing", [constructor], [constructorPath])
+  writer.mapped("constructor", {mappingKind: "exact", node: constructor, path: constructorPath, role: "constructor"})
+  emitParameters(writer, constructor.parameters, `${constructorPath}/parameters`)
+  writer.synthetic(" {\n", "constructor open", [constructor], [constructorPath])
+  emitBlock(writer, constructor.body, "    ", `${constructorPath}/body`, canonicalizeZero)
+  writer.synthetic("  }", "constructor close", [constructor], [constructorPath])
+  declaration.methods.forEach((method, index) => {
+    const methodPath = `${path}/methods/${index}`
+
+    writer.synthetic("\n\n  ", "method spacing", [method], [methodPath])
+    writer.mapped(method.name, {mappingKind: "exact", node: method, path: methodPath, role: "name"})
+    emitParameters(writer, method.parameters, `${methodPath}/parameters`)
+    writer.synthetic(": ", "method return separator", [method], [methodPath])
+    emitType(writer, method.returnType, `${methodPath}/returnType`, "typescript")
+    writer.synthetic(" {\n", "method open", [method], [methodPath])
+    emitBlock(writer, method.body, "    ", `${methodPath}/body`, canonicalizeZero)
+    writer.synthetic("  }", "method close", [method], [methodPath])
+  })
+  writer.synthetic("\n", "line break", [declaration], [path])
+  writer.mapped("}", {mappingKind: "anchor", node: declaration, path})
+}
+
+/**
+ * Emits one TypeScript parameter list.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Parameter[]} parameters - Ordered parameters.
+ * @param {string} path - Parameter collection path.
+ * @returns {void}
+ */
+function emitParameters(writer, parameters, path) {
+  writer.synthetic("(", "parameter list open", parameters)
+  parameters.forEach((parameter, index) => {
+    const parameterPath = `${path}/${index}`
+
+    if (index) writer.synthetic(", ", "parameter separator", parameters)
+    writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: parameterPath, role: "name"})
+    writer.synthetic(": ", "parameter type separator", [parameter], [parameterPath])
+    emitType(writer, parameter.type, `${parameterPath}/type`, "typescript")
+  })
+  writer.synthetic(")", "parameter list close", parameters)
+}
+
+/**
+ * Emits native invariant TypeScript declaration parameters.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").TypeParameter[]} parameters - Ordered type parameters.
+ * @param {string} path - Type-parameter collection path.
+ */
+function emitTypeParameters(writer, parameters, path) {
+  if (parameters.length == 0) return
+  writer.synthetic("<", "TypeScript type parameter open", parameters)
+  parameters.forEach((parameter, index) => {
+    if (index) writer.synthetic(", ", "TypeScript type parameter separator", parameters)
+    writer.mapped(parameter.name, {mappingKind: "exact", node: parameter, path: `${path}/${index}`, role: "name"})
+  })
+  writer.synthetic(">", "TypeScript type parameter close", parameters)
+}
+
+/**
+ * Emits grouped value and type-only ESM imports for a program module.
+ * @param {import("../semantic/types.js").SemanticModule} module - Current module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ */
+function emitProgramImports(module, writer) {
+  if (!writer.program) return
+  const imports = /** @type {import("../semantic/types.js").SemanticProgramModule} */ (/** @type {unknown} */ (module)).imports
+  const groups = []
+
+  for (const moduleId of [...new Set(imports.map((item) => item.moduleId))]) {
+    const selected = imports.filter((item) => item.moduleId == moduleId)
+    const typeOnly = selected.filter((item) => item.typeOnly)
+    const values = selected.filter((item) => !item.typeOnly)
+
+    if (typeOnly.length > 0) groups.push({items: typeOnly, moduleId, typeOnly: true})
+    if (values.length > 0) groups.push({items: values, moduleId, typeOnly: false})
+  }
+  for (const group of groups) {
+    writer.synthetic(group.typeOnly ? "import type {" : "import {", "TypeScript ESM import declaration", group.items)
+    group.items.forEach((item, index) => {
+      const itemPath = `/imports/${imports.indexOf(item)}`
+      const localName = writer.importNameFor(item)
+
+      if (index) writer.synthetic(", ", "ESM import separator", group.items)
+      writer.mapped(item.importedName, {mappingKind: "exact", node: item, path: itemPath, role: "importedName"})
+      if (localName != item.importedName) {
+        writer.synthetic(" as ", "ESM import alias", [item], [itemPath])
+        writer.mapped(localName, {mappingKind: "exact", node: item, path: itemPath, role: "localName"})
+      }
+    })
+    writer.synthetic("} from ", "ESM import source", group.items)
+    writer.mapped(JSON.stringify(writer.relativeModuleSpecifier(group.moduleId, ".js")), {
+      mappingKind: "anchor", node: group.items[0], path: `/imports/${imports.indexOf(group.items[0])}`, role: "path"
+    })
+    writer.synthetic("\n", "ESM import terminator", group.items)
+  }
+  if (groups.length > 0) writer.synthetic("\n", "ESM import separator", [module])
+  emitStdlibProviderImports(module, writer)
+}
+
+/**
+ * Emits the grouped named ESM import for one linked stdlib provider.
+ * @param {import("../semantic/types.js").SemanticModule} module - Current module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ */
+function emitStdlibProviderImports(module, writer) {
+  const names = writer.stdlibProviderImports
+
+  if (!writer.program || !names || names.length == 0) return
+
+  writer.synthetic("import {", "ESM stdlib provider import declaration", [module])
+  names.forEach((name, index) => {
+    if (index) writer.synthetic(", ", "ESM stdlib provider import separator", [module])
+    writer.synthetic(name, "ESM stdlib provider import name", [module])
+  })
+  writer.synthetic("} from ", "ESM stdlib provider import source", [module])
+  writer.synthetic(JSON.stringify(writer.stdlibProviderSpecifier(".js")), "ESM stdlib provider import path", [module])
+  writer.synthetic("\n", "ESM stdlib provider import terminator", [module])
+  writer.synthetic("\n", "ESM stdlib provider import separator", [module])
+}
+
+/**
+ * Emits explicit ESM export clauses for source aliases.
+ * @param {import("../semantic/types.js").SemanticModule} module - Current module.
+ * @param {import("./writer.js").SourceWriter} writer - Source-aware writer.
+ */
+function emitAliasedExports(module, writer) {
+  if (!writer.program) return
+  const programModule = /** @type {import("../semantic/types.js").SemanticProgramModule} */ (/** @type {unknown} */ (module))
+  const aliases = programModule.exports.filter((item) => !writer.isDirectExport(item))
+
+  if (aliases.length == 0) return
+  writer.synthetic("\n\nexport {", "ESM aliased exports", [module])
+  aliases.forEach((item, index) => {
+    if (index) writer.synthetic(", ", "ESM export separator", [module])
+    const declaration = [...programModule.functions, ...(programModule.records ?? []), ...(programModule.errors ?? [])].find(({id}) => id == item.declarationId)
+
+    if (!declaration) throw new RangeError(`Unknown exported declaration '${item.declarationId}'.`)
+    const exportPath = `/exports/${programModule.exports.indexOf(item)}`
+
+    writer.mapped(declaration.name, {mappingKind: "exact", name: declaration.name, node: item, path: exportPath, role: "localName"})
+    writer.synthetic(" as ", "ESM aliased export operator", [item], [exportPath])
+    writer.mapped(item.exportedName, {mappingKind: "exact", name: item.exportedName, node: item, path: exportPath, role: "exportedName"})
+  })
+  writer.synthetic("}", "ESM aliased export close", [module])
 }
 
 /**
@@ -75,15 +290,131 @@ function emitBlock(writer, block, indent, path, canonicalizeZero) {
  * @returns {void}
  */
 function emitStatement(writer, statement, indent, path, canonicalizeZero) {
+  emitEffectPrefixes(writer, statement, indent, path, "typescript",
+    (expression, expressionPath) => emitExpression(writer, expression, expressionPath, "typescript", identity))
   if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") {
     emitLocal(writer, statement, indent, path)
     writer.synthetic("\n", "line break", [statement], [path])
     return
   }
   writer.synthetic(indent, "indentation", [statement], [path])
+  if (statement.kind == "PrivateFieldWriteStatement") {
+    emitExpression(writer, statement.receiver, `${path}/receiver`, "typescript", identity)
+    const field = writer.privateFieldForId(statement.field)
+
+    writer.mapped(`.${field.name}`, {mappingKind: "exact", name: field.name, node: statement, path, role: "member"})
+    writer.synthetic(" = ", "private field assignment", [statement], [path])
+    emitExpression(writer, statement.expression, `${path}/expression`, "typescript", identity)
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "BreakStatement" || statement.kind == "ContinueStatement") {
+    writer.mapped(statement.kind == "BreakStatement" ? "break" : "continue", {mappingKind: "exact", node: statement, path})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "WhileStatement") {
+    writer.mapped("while", {mappingKind: "exact", node: statement, path})
+    writer.synthetic(" (", "condition-controlled loop spacing", [statement], [path])
+    emitExpression(writer, statement.condition, `${path}/condition`, "typescript", identity)
+    writer.synthetic(") ", "condition-controlled loop spacing", [statement], [path])
+    writer.mapped("{", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`, canonicalizeZero)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "ForEachStatement") {
+    writer.mapped("for", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" (const ", "loop scaffolding", [statement], [path])
+    writer.mapped(statement.valueBinding.name, {
+      mappingKind: "exact", node: statement.valueBinding, path: `${path}/valueBinding`, role: "name"
+    })
+    writer.synthetic(" of ", "loop scaffolding", [statement], [path])
+    emitExpression(writer, statement.list, `${path}/list`, "typescript", identity)
+    writer.synthetic(") ", "loop scaffolding", [statement], [path])
+    writer.mapped("{", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`, canonicalizeZero)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "ForEachMapStatement") {
+    writer.mapped("for", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" (const [", "map loop scaffolding", [statement], [path])
+    writer.mapped(statement.keyBinding.name, {
+      mappingKind: "exact", node: statement.keyBinding, path: `${path}/keyBinding`, role: "name"
+    })
+    writer.synthetic(", ", "map iteration binding separator", [statement], [path])
+    writer.mapped(statement.valueBinding.name, {
+      mappingKind: "exact", node: statement.valueBinding, path: `${path}/valueBinding`, role: "name"
+    })
+    writer.synthetic("] of ", "map loop scaffolding", [statement], [path])
+    emitExpression(writer, statement.map, `${path}/map`, "typescript", identity)
+    writer.synthetic(") ", "map loop scaffolding", [statement], [path])
+    writer.mapped("{", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`, canonicalizeZero)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "RaiseStatement") {
+    const type = statement.error.error
+    const error = writer.errorForId(type.declarationId)
+
+    writer.mapped("throw", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" new ", "error construction scaffolding", [statement.error], [`${path}/error`])
+    writer.mapped(writer.errorNameForId(type.declarationId), {mappingKind: "exact", name: error.name, node: statement.error, path: `${path}/error`, role: "type"})
+    writer.synthetic("(", "error construction open", [statement.error], [`${path}/error`])
+    emitExpression(writer, statement.error.message, `${path}/error/message`, "typescript", identity)
+    writer.synthetic(")\n", "error construction close", [statement.error], [`${path}/error`])
+    return
+  }
+  if (statement.kind == "TryStatement") {
+    const caught = writer.errorForId(statement.catchType.declarationId)
+    const targetName = writer.errorNameForId(statement.catchType.declarationId)
+
+    writer.mapped("try", {mappingKind: "anchor", node: statement, path})
+    writer.synthetic(" ", "try spacing", [statement], [path])
+    writer.mapped("{", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    emitBlock(writer, statement.body, `${indent}  `, `${path}/body`, canonicalizeZero)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.body, path: `${path}/body`})
+    writer.synthetic(" ", "catch spacing", [statement], [path])
+    writer.mapped("catch", {mappingKind: "anchor", node: statement, path, role: "catch"})
+    writer.synthetic(" (", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
+    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
+    writer.synthetic(") {\n", "catch binding scaffolding", [statement.catchBinding], [`${path}/catchBinding`])
+    writer.synthetic(`${indent}  if (!(`, "exact catch guard", [statement], [path])
+    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
+    writer.synthetic(" instanceof ", "exact catch guard", [statement], [path])
+    writer.mapped(targetName, {mappingKind: "exact", name: caught.name, node: statement.catchType, path: `${path}/catchType`, role: "type"})
+    writer.synthetic(`)) {\n${indent}    throw `, "unmatched error propagation", [statement], [path])
+    writer.mapped(statement.catchBinding.name, {mappingKind: "exact", node: statement.catchBinding, path: `${path}/catchBinding`, role: "name"})
+    writer.synthetic(`\n${indent}  }\n`, "unmatched error propagation", [statement], [path])
+    emitBlock(writer, statement.catchBody, `${indent}  `, `${path}/catchBody`, canonicalizeZero)
+    writer.synthetic(indent, "indentation", [statement], [path])
+    writer.mapped("}", {mappingKind: "anchor", node: statement.catchBody, path: `${path}/catchBody`})
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
   if (statement.kind == "ReturnStatement") {
     writer.mapped("return", {mappingKind: "anchor", node: statement, path})
-    writer.synthetic(" ", "return spacing", [statement], [path])
+    if (statement.expression) {
+      writer.synthetic(" ", "return spacing", [statement], [path])
+      emitExpression(writer, statement.expression, `${path}/expression`, "typescript", identity)
+    }
+    writer.synthetic("\n", "line break", [statement], [path])
+    return
+  }
+  if (statement.kind == "ExpressionStatement") {
     emitExpression(writer, statement.expression, `${path}/expression`, "typescript", identity)
     writer.synthetic("\n", "line break", [statement], [path])
     return
@@ -146,12 +477,7 @@ function emitLocal(writer, statement, indent, statementPath) {
   writer.synthetic(" ", "declaration spacing", [statement], [statementPath])
   writer.mapped(statement.name, {mappingKind: "exact", node: statement, path: statementPath, role: "name"})
   writer.synthetic(": ", "type separator", [statement], [statementPath])
-  writer.mapped(emitScalarType("typescript", statement.type), {
-    mappingKind: "exact",
-    node: statement.type,
-    path: `${statementPath}/type`,
-    role: "type"
-  })
+  emitType(writer, statement.type, `${statementPath}/type`, "typescript")
   writer.synthetic(" ", "assignment spacing", [statement], [statementPath])
   writer.mapped("=", {mappingKind: "exact", node: statement, path: statementPath, role: "operator"})
   writer.synthetic(" ", "assignment spacing", [statement], [statementPath])