semantifold 0.1.1 → 0.3.0

package/build/src/backends/csharp.js

@@ -0,0 +1,259 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { validateBackendModule, emitExpression } from "./shared.js";
+import { emitScalarType } from "./scalars.js";
+import { SourceWriter } from "./writer.js";
+const project = `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>14.0</LangVersion>
+    <Nullable>enable</Nullable>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <WarningLevel>10</WarningLevel>
+    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>
+    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <EnableNETAnalyzers>false</EnableNETAnalyzers>
+    <InvariantGlobalization>true</InvariantGlobalization>
+    <PredefinedCulturesOnly>true</PredefinedCulturesOnly>
+    <Deterministic>true</Deterministic>
+    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+    <DebugType>none</DebugType>
+    <UseAppHost>false</UseAppHost>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    <AssemblyName>Semantifold</AssemblyName>
+    <RootNamespace>Semantifold.Generated</RootNamespace>
+    <StartupObject>Semantifold.Generated.Program</StartupObject>
+    <PathMap>$(MSBuildProjectDirectory)=/_/</PathMap>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+  </ItemGroup>
+</Project>
+`;
+/**
+ * Emits one deterministic two-file C# project candidate.
+ * @param {{filename?: string, mapDirective?: unknown, module: import("../semantic/types.js").SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input - Backend request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Candidate artifact set.
+ */
+export function generateCSharpProject({ filename, mapDirective, module, sourceMapFilename, sources }) {
+    validateBackendModule(module, "csharp");
+    if (filename !== undefined && filename != "Program.cs") {
+        unsupportedCapability("csharp", "artifact filename other than Program.cs", module.location);
+    }
+    if (mapDirective !== undefined || sourceMapFilename !== undefined) {
+        unsupportedCapability("csharp", "source-map filename or directive option", module.location);
+    }
+    const writer = new SourceWriter({ filename: "Program.cs", language: "csharp", module, sources });
+    emitProgram(module, writer);
+    const mapping = finalizeMapping(writer.finish());
+    const root = mapping.nodes.find(({ path }) => path == "");
+    if (!root)
+        throw new Error("Validated C# module omitted its canonical root provenance.");
+    return {
+        artifacts: [{
+                content: mapping.generated.content,
+                contentKind: "text",
+                mediaType: "text/x-csharp",
+                ownership: "generated",
+                path: "Program.cs",
+                provenance: { kind: "text", mapping, sourceMap: toSourceMapV3(mapping) },
+                role: "entry"
+            }, {
+                content: project,
+                contentKind: "text",
+                mediaType: "application/xml",
+                ownership: "generated",
+                path: "Semantifold.csproj",
+                provenance: { kind: "synthetic", reason: "Deterministic .NET 10 project manifest for the generated C# module.",
+                    relatedOrigins: relatedRootOrigins(root) },
+                role: "manifest"
+            }],
+        target: "csharp"
+    };
+}
+/**
+ * Emits the fixed C# file scaffold and semantic bodies.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+ * @param {SourceWriter} writer - Source-aware writer.
+ * @returns {void}
+ */
+function emitProgram(module, writer) {
+    writer.synthetic("#nullable enable\n\nnamespace Semantifold.Generated;\n\ninternal static class Program\n{\n", "C# nullable, namespace, and Program scaffolding", [module]);
+    module.functions.forEach((declaration, index) => {
+        if (index > 0)
+            writer.synthetic("\n", "declaration separator", [declaration]);
+        emitFunction(writer, declaration, index);
+    });
+    writer.synthetic("\n", "entry-point separator", [module.entryPoint]);
+    writer.synthetic("    ", "indentation", [module.entryPoint]);
+    writer.mapped("private static void Main", { mappingKind: "anchor", node: module.entryPoint });
+    writer.mapped("()", { mappingKind: "anchor", node: module.entryPoint });
+    writer.synthetic("\n    ", "line break and indentation", [module.entryPoint]);
+    writer.mapped("{", { mappingKind: "anchor", node: module.entryPoint });
+    writer.synthetic("\n", "line break", [module.entryPoint]);
+    emitBlock(writer, module.entryPoint.body, "        ", "/entryPoint/body");
+    writer.synthetic("    ", "indentation", [module.entryPoint]);
+    writer.mapped("}", { mappingKind: "anchor", node: module.entryPoint });
+    writer.synthetic("\n}\n", "C# Program scaffolding", [module]);
+}
+/**
+ * Emits one private static semantic method.
+ * @param {SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").FunctionDeclaration} declaration - Function declaration.
+ * @param {number} index - Function index.
+ * @returns {void}
+ */
+function emitFunction(writer, declaration, index) {
+    const path = `/functions/${index}`;
+    writer.synthetic("    ", "indentation", [declaration], [path]);
+    writer.mapped("private static", { mappingKind: "anchor", node: declaration, path });
+    writer.synthetic(" ", "method spacing", [declaration], [path]);
+    writer.mapped(emitScalarType("csharp", declaration.returnType), {
+        mappingKind: "exact", node: declaration.returnType, path: `${path}/returnType`, role: "type"
+    });
+    writer.synthetic(" ", "method spacing", [declaration], [path]);
+    writer.mapped(declaration.name, { mappingKind: "exact", node: declaration, path, role: "name" });
+    writer.mapped("(", { mappingKind: "anchor", node: declaration, path });
+    declaration.parameters.forEach((parameter, parameterIndex) => {
+        const parameterPath = `${path}/parameters/${parameterIndex}`;
+        if (parameterIndex > 0)
+            writer.synthetic(", ", "parameter separator", [declaration], [path]);
+        writer.mapped(emitScalarType("csharp", parameter.type), {
+            mappingKind: "exact", node: parameter.type, path: `${parameterPath}/type`, role: "type"
+        });
+        writer.synthetic(" ", "parameter spacing", [parameter], [parameterPath]);
+        writer.mapped(parameter.name, { mappingKind: "exact", node: parameter, path: parameterPath, role: "name" });
+    });
+    writer.mapped(")", { mappingKind: "anchor", node: declaration, path });
+    writer.synthetic("\n    ", "line break and indentation", [declaration], [path]);
+    writer.mapped("{", { mappingKind: "anchor", node: declaration.body, path: `${path}/body` });
+    writer.synthetic("\n", "line break", [declaration], [path]);
+    emitBlock(writer, declaration.body, "        ", `${path}/body`);
+    writer.synthetic("    ", "indentation", [declaration], [path]);
+    writer.mapped("}", { mappingKind: "anchor", node: declaration, path });
+    writer.synthetic("\n", "line break", [declaration], [path]);
+}
+/**
+ * Emits one ordered semantic block.
+ * @param {SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @param {string} indent - Current indentation.
+ * @param {string} path - Exact semantic path.
+ * @returns {void}
+ */
+function emitBlock(writer, block, indent, path) {
+    block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`));
+}
+/**
+ * Emits one supported C# statement.
+ * @param {SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").Statement} statement - Semantic statement.
+ * @param {string} indent - Current indentation.
+ * @param {string} path - Exact semantic path.
+ * @returns {void}
+ */
+function emitStatement(writer, statement, indent, path) {
+    if (statement.kind == "LocalDeclaration" || statement.kind == "AssignmentStatement") {
+        return emitLocal(writer, statement, indent, path);
+    }
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    if (statement.kind == "ReturnStatement") {
+        writer.mapped("return", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic(" ", "return spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "csharp", identity);
+        writer.mapped(";", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    if (statement.kind == "PrintStatement") {
+        writer.mapped("System.Console.WriteLine", { mappingKind: "anchor", node: statement, path });
+        writer.mapped("(", { mappingKind: "anchor", node: statement, path });
+        emitExpression(writer, statement.expression, `${path}/expression`, "csharp", identity);
+        writer.mapped(");", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic("\n", "line break", [statement], [path]);
+        return;
+    }
+    writer.mapped("if", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic(" ", "conditional spacing", [statement], [path]);
+    writer.mapped("(", { mappingKind: "anchor", node: statement, path });
+    emitExpression(writer, statement.condition, `${path}/condition`, "csharp", identity);
+    writer.mapped(")", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic("\n", "line break", [statement], [path]);
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    writer.mapped("{", { mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent` });
+    writer.synthetic("\n", "line break", [statement], [path]);
+    emitBlock(writer, statement.consequent, `${indent}    `, `${path}/consequent`);
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    writer.mapped("}", { mappingKind: "anchor", node: statement.consequent, path: `${path}/consequent` });
+    if (statement.alternate) {
+        writer.synthetic("\n", "line break", [statement], [path]);
+        writer.synthetic(indent, "indentation", [statement], [path]);
+        writer.mapped("else", { mappingKind: "anchor", node: statement, path });
+        writer.synthetic("\n", "line break", [statement], [path]);
+        writer.synthetic(indent, "indentation", [statement], [path]);
+        writer.mapped("{", { mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate` });
+        writer.synthetic("\n", "line break", [statement], [path]);
+        emitBlock(writer, statement.alternate, `${indent}    `, `${path}/alternate`);
+        writer.synthetic(indent, "indentation", [statement], [path]);
+        writer.mapped("}", { mappingKind: "anchor", node: statement.alternate, path: `${path}/alternate` });
+    }
+    writer.synthetic("\n", "line break", [statement], [path]);
+}
+/**
+ * Emits one local declaration or assignment.
+ * @param {SourceWriter} writer - Source-aware writer.
+ * @param {import("../semantic/types.js").LocalStatement} statement - Local statement.
+ * @param {string} indent - Current indentation.
+ * @param {string} path - Exact semantic path.
+ * @returns {void}
+ */
+function emitLocal(writer, statement, indent, path) {
+    if (statement.kind == "LocalDeclaration" && !statement.mutable) {
+        writer.synthetic(`${indent}// @semantifold-immutable\n`, "C# immutable-local carrier", [statement], [path]);
+    }
+    writer.synthetic(indent, "indentation", [statement], [path]);
+    if (statement.kind == "AssignmentStatement") {
+        writer.mapped(statement.target.name, { mappingKind: "exact", node: statement.target, path: `${path}/target`, role: "name" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        writer.mapped("=", { mappingKind: "exact", node: statement, path, role: "operator" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        emitExpression(writer, statement.expression, `${path}/expression`, "csharp", identity);
+    }
+    else {
+        writer.mapped(emitScalarType("csharp", statement.type), {
+            mappingKind: "exact", node: statement.type, path: `${path}/type`, role: "type"
+        });
+        writer.synthetic(" ", "declaration spacing", [statement], [path]);
+        writer.mapped(statement.name, { mappingKind: "exact", node: statement, path, role: "name" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        writer.mapped("=", { mappingKind: "exact", node: statement, path, role: "operator" });
+        writer.synthetic(" ", "assignment spacing", [statement], [path]);
+        emitExpression(writer, statement.initializer, `${path}/initializer`, "csharp", identity);
+    }
+    writer.mapped(";", { mappingKind: "anchor", node: statement, path });
+    writer.synthetic("\n", "line break", [statement], [path]);
+}
+/**
+ * Converts canonical module-root provenance to artifact-level related origins.
+ * @param {import("../semantic/types.js").SemanticNodeProvenance} root - Canonical root provenance.
+ * @returns {import("../semantic/types.js").RelatedOrigin[]} Related module origins.
+ */
+function relatedRootOrigins(root) {
+    if (root.origin.kind == "source") {
+        return [{ location: root.origin.location, nodeId: root.id, role: "module", sourceId: root.origin.sourceId }];
+    }
+    const origins = root.origin.kind == "derived" ? root.origin.origins : root.origin.relatedOrigins;
+    return origins.map((origin) => ({ ...origin, nodeId: origin.nodeId ?? root.id, role: origin.role ?? "module" }));
+}
+/**
+ * Preserves an already validated C# identifier spelling.
+ * @param {string} name - Identifier.
+ * @returns {string} Unchanged identifier.
+ */
+function identity(name) {
+    return name;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"csharp.js","sourceRoot":"","sources":["../../../src/backends/csharp.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {validateBackendModule, emitExpression} from \"./shared.js\"\nimport {emitScalarType} from \"./scalars.js\"\nimport {SourceWriter} from \"./writer.js\"\n\nconst project = `<Project Sdk=\"Microsoft.NET.Sdk\">\n  <PropertyGroup>\n    <OutputType>Exe</OutputType>\n    <TargetFramework>net10.0</TargetFramework>\n    <LangVersion>14.0</LangVersion>\n    <Nullable>enable</Nullable>\n    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>\n    <WarningLevel>10</WarningLevel>\n    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>\n    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>\n    <ImplicitUsings>disable</ImplicitUsings>\n    <EnableNETAnalyzers>false</EnableNETAnalyzers>\n    <InvariantGlobalization>true</InvariantGlobalization>\n    <PredefinedCulturesOnly>true</PredefinedCulturesOnly>\n    <Deterministic>true</Deterministic>\n    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>\n    <DebugType>none</DebugType>\n    <UseAppHost>false</UseAppHost>\n    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>\n    <AssemblyName>Semantifold</AssemblyName>\n    <RootNamespace>Semantifold.Generated</RootNamespace>\n    <StartupObject>Semantifold.Generated.Program</StartupObject>\n    <PathMap>$(MSBuildProjectDirectory)=/_/</PathMap>\n  </PropertyGroup>\n  <ItemGroup>\n    <Compile Include=\"Program.cs\" />\n  </ItemGroup>\n</Project>\n`\n\n/**\n * Emits one deterministic two-file C# project candidate.\n * @param {{filename?: string, mapDirective?: unknown, module: import(\"../semantic/types.js\").SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} input - Backend request.\n * @returns {{artifacts: import(\"../semantic/types.js\").GeneratedSetArtifact[], target: string}} Candidate artifact set.\n */\nexport function generateCSharpProject({filename, mapDirective, module, sourceMapFilename, sources}) {\n  validateBackendModule(module, \"csharp\")\n  if (filename !== undefined && filename != \"Program.cs\") {\n    unsupportedCapability(\"csharp\", \"artifact filename other than Program.cs\", module.location)\n  }\n  if (mapDirective !== undefined || sourceMapFilename !== undefined) {\n    unsupportedCapability(\"csharp\", \"source-map filename or directive option\", module.location)\n  }\n  const writer = new SourceWriter({filename: \"Program.cs\", language: \"csharp\", module, sources})\n\n  emitProgram(module, writer)\n  const mapping = finalizeMapping(writer.finish())\n  const root = mapping.nodes.find(({path}) => path == \"\")\n\n  if (!root) throw new Error(\"Validated C# module omitted its canonical root provenance.\")\n  return {\n    artifacts: [{\n      content: mapping.generated.content,\n      contentKind: \"text\",\n      mediaType: \"text/x-csharp\",\n      ownership: \"generated\",\n      path: \"Program.cs\",\n      provenance: {kind: \"text\", mapping, sourceMap: toSourceMapV3(mapping)},\n      role: \"entry\"\n    }, {\n      content: project,\n      contentKind: \"text\",\n      mediaType: \"application/xml\",\n      ownership: \"generated\",\n      path: \"Semantifold.csproj\",\n      provenance: {kind: \"synthetic\", reason: \"Deterministic .NET 10 project manifest for the generated C# module.\",\n        relatedOrigins: relatedRootOrigins(root)},\n      role: \"manifest\"\n    }],\n    target: \"csharp\"\n  }\n}\n\n/**\n * Emits the fixed C# file scaffold and semantic bodies.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated module.\n * @param {SourceWriter} writer - Source-aware writer.\n * @returns {void}\n */\nfunction emitProgram(module, writer) {\n  writer.synthetic(\"#nullable enable\\n\\nnamespace Semantifold.Generated;\\n\\ninternal static class Program\\n{\\n\",\n    \"C# nullable, namespace, and Program scaffolding\", [module])\n  module.functions.forEach((declaration, index) => {\n    if (index > 0) writer.synthetic(\"\\n\", \"declaration separator\", [declaration])\n    emitFunction(writer, declaration, index)\n  })\n  writer.synthetic(\"\\n\", \"entry-point separator\", [module.entryPoint])\n  writer.synthetic(\"    \", \"indentation\", [module.entryPoint])\n  writer.mapped(\"private static void Main\", {mappingKind: \"anchor\", node: module.entryPoint})\n  writer.mapped(\"()\", {mappingKind: \"anchor\", node: module.entryPoint})\n  writer.synthetic(\"\\n    \", \"line break and indentation\", [module.entryPoint])\n  writer.mapped(\"{\", {mappingKind: \"anchor\", node: module.entryPoint})\n  writer.synthetic(\"\\n\", \"line break\", [module.entryPoint])\n  emitBlock(writer, module.entryPoint.body, \"        \", \"/entryPoint/body\")\n  writer.synthetic(\"    \", \"indentation\", [module.entryPoint])\n  writer.mapped(\"}\", {mappingKind: \"anchor\", node: module.entryPoint})\n  writer.synthetic(\"\\n}\\n\", \"C# Program scaffolding\", [module])\n}\n\n/**\n * Emits one private static semantic method.\n * @param {SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").FunctionDeclaration} declaration - Function declaration.\n * @param {number} index - Function index.\n * @returns {void}\n */\nfunction emitFunction(writer, declaration, index) {\n  const path = `/functions/${index}`\n\n  writer.synthetic(\"    \", \"indentation\", [declaration], [path])\n  writer.mapped(\"private static\", {mappingKind: \"anchor\", node: declaration, path})\n  writer.synthetic(\" \", \"method spacing\", [declaration], [path])\n  writer.mapped(emitScalarType(\"csharp\", declaration.returnType), {\n    mappingKind: \"exact\", node: declaration.returnType, path: `${path}/returnType`, role: \"type\"\n  })\n  writer.synthetic(\" \", \"method spacing\", [declaration], [path])\n  writer.mapped(declaration.name, {mappingKind: \"exact\", node: declaration, path, role: \"name\"})\n  writer.mapped(\"(\", {mappingKind: \"anchor\", node: declaration, path})\n  declaration.parameters.forEach((parameter, parameterIndex) => {\n    const parameterPath = `${path}/parameters/${parameterIndex}`\n\n    if (parameterIndex > 0) writer.synthetic(\", \", \"parameter separator\", [declaration], [path])\n    writer.mapped(emitScalarType(\"csharp\", parameter.type), {\n      mappingKind: \"exact\", node: parameter.type, path: `${parameterPath}/type`, role: \"type\"\n    })\n    writer.synthetic(\" \", \"parameter spacing\", [parameter], [parameterPath])\n    writer.mapped(parameter.name, {mappingKind: \"exact\", node: parameter, path: parameterPath, role: \"name\"})\n  })\n  writer.mapped(\")\", {mappingKind: \"anchor\", node: declaration, path})\n  writer.synthetic(\"\\n    \", \"line break and indentation\", [declaration], [path])\n  writer.mapped(\"{\", {mappingKind: \"anchor\", node: declaration.body, path: `${path}/body`})\n  writer.synthetic(\"\\n\", \"line break\", [declaration], [path])\n  emitBlock(writer, declaration.body, \"        \", `${path}/body`)\n  writer.synthetic(\"    \", \"indentation\", [declaration], [path])\n  writer.mapped(\"}\", {mappingKind: \"anchor\", node: declaration, path})\n  writer.synthetic(\"\\n\", \"line break\", [declaration], [path])\n}\n\n/**\n * Emits one ordered semantic block.\n * @param {SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @param {string} indent - Current indentation.\n * @param {string} path - Exact semantic path.\n * @returns {void}\n */\nfunction emitBlock(writer, block, indent, path) {\n  block.statements.forEach((statement, index) => emitStatement(writer, statement, indent, `${path}/statements/${index}`))\n}\n\n/**\n * Emits one supported C# statement.\n * @param {SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").Statement} statement - Semantic statement.\n * @param {string} indent - Current indentation.\n * @param {string} path - Exact semantic path.\n * @returns {void}\n */\nfunction emitStatement(writer, statement, indent, path) {\n  if (statement.kind == \"LocalDeclaration\" || statement.kind == \"AssignmentStatement\") {\n    return emitLocal(writer, statement, indent, path)\n  }\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  if (statement.kind == \"ReturnStatement\") {\n    writer.mapped(\"return\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\" \", \"return spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"csharp\", identity)\n    writer.mapped(\";\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  if (statement.kind == \"PrintStatement\") {\n    writer.mapped(\"System.Console.WriteLine\", {mappingKind: \"anchor\", node: statement, path})\n    writer.mapped(\"(\", {mappingKind: \"anchor\", node: statement, path})\n    emitExpression(writer, statement.expression, `${path}/expression`, \"csharp\", identity)\n    writer.mapped(\");\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    return\n  }\n  writer.mapped(\"if\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\" \", \"conditional spacing\", [statement], [path])\n  writer.mapped(\"(\", {mappingKind: \"anchor\", node: statement, path})\n  emitExpression(writer, statement.condition, `${path}/condition`, \"csharp\", identity)\n  writer.mapped(\")\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  writer.mapped(\"{\", {mappingKind: \"anchor\", node: statement.consequent, path: `${path}/consequent`})\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n  emitBlock(writer, statement.consequent, `${indent}    `, `${path}/consequent`)\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  writer.mapped(\"}\", {mappingKind: \"anchor\", node: statement.consequent, path: `${path}/consequent`})\n  if (statement.alternate) {\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    writer.synthetic(indent, \"indentation\", [statement], [path])\n    writer.mapped(\"else\", {mappingKind: \"anchor\", node: statement, path})\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    writer.synthetic(indent, \"indentation\", [statement], [path])\n    writer.mapped(\"{\", {mappingKind: \"anchor\", node: statement.alternate, path: `${path}/alternate`})\n    writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n    emitBlock(writer, statement.alternate, `${indent}    `, `${path}/alternate`)\n    writer.synthetic(indent, \"indentation\", [statement], [path])\n    writer.mapped(\"}\", {mappingKind: \"anchor\", node: statement.alternate, path: `${path}/alternate`})\n  }\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n}\n\n/**\n * Emits one local declaration or assignment.\n * @param {SourceWriter} writer - Source-aware writer.\n * @param {import(\"../semantic/types.js\").LocalStatement} statement - Local statement.\n * @param {string} indent - Current indentation.\n * @param {string} path - Exact semantic path.\n * @returns {void}\n */\nfunction emitLocal(writer, statement, indent, path) {\n  if (statement.kind == \"LocalDeclaration\" && !statement.mutable) {\n    writer.synthetic(`${indent}// @semantifold-immutable\\n`, \"C# immutable-local carrier\", [statement], [path])\n  }\n  writer.synthetic(indent, \"indentation\", [statement], [path])\n  if (statement.kind == \"AssignmentStatement\") {\n    writer.mapped(statement.target.name, {mappingKind: \"exact\", node: statement.target, path: `${path}/target`, role: \"name\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path, role: \"operator\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    emitExpression(writer, statement.expression, `${path}/expression`, \"csharp\", identity)\n  } else {\n    writer.mapped(emitScalarType(\"csharp\", statement.type), {\n      mappingKind: \"exact\", node: statement.type, path: `${path}/type`, role: \"type\"\n    })\n    writer.synthetic(\" \", \"declaration spacing\", [statement], [path])\n    writer.mapped(statement.name, {mappingKind: \"exact\", node: statement, path, role: \"name\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    writer.mapped(\"=\", {mappingKind: \"exact\", node: statement, path, role: \"operator\"})\n    writer.synthetic(\" \", \"assignment spacing\", [statement], [path])\n    emitExpression(writer, statement.initializer, `${path}/initializer`, \"csharp\", identity)\n  }\n  writer.mapped(\";\", {mappingKind: \"anchor\", node: statement, path})\n  writer.synthetic(\"\\n\", \"line break\", [statement], [path])\n}\n\n/**\n * Converts canonical module-root provenance to artifact-level related origins.\n * @param {import(\"../semantic/types.js\").SemanticNodeProvenance} root - Canonical root provenance.\n * @returns {import(\"../semantic/types.js\").RelatedOrigin[]} Related module origins.\n */\nfunction relatedRootOrigins(root) {\n  if (root.origin.kind == \"source\") {\n    return [{location: root.origin.location, nodeId: root.id, role: \"module\", sourceId: root.origin.sourceId}]\n  }\n  const origins = root.origin.kind == \"derived\" ? root.origin.origins : root.origin.relatedOrigins\n\n  return origins.map((origin) => ({...origin, nodeId: origin.nodeId ?? root.id, role: origin.role ?? \"module\"}))\n}\n\n/**\n * Preserves an already validated C# identifier spelling.\n * @param {string} name - Identifier.\n * @returns {string} Unchanged identifier.\n */\nfunction identity(name) {\n  return name\n}\n"]}

package/build/src/backends/go.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Emits one deterministic manifest-first Go module candidate.
+ * @param {{filename?: string, mapDirective?: unknown, module: import("../semantic/types.js").SemanticModule, sourceMapFilename?: unknown, sources?: {filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} input Backend request.
+ * @returns {{artifacts: import("../semantic/types.js").GeneratedSetArtifact[], target: string}} Candidate artifact set.
+ */
+export declare function generateGoModule({ filename, mapDirective, module, sourceMapFilename, sources }: {
+    filename?: string;
+    mapDirective?: unknown;
+    module: import("../semantic/types.js").SemanticModule;
+    sourceMapFilename?: unknown;
+    sources?: {
+        filename: string;
+        content: string;
+        language?: import("../semantic/types.js").SemanticLanguage;
+    }[];
+}): {
+    artifacts: import("../semantic/types.js").GeneratedSetArtifact[];
+    target: string;
+};
+//# sourceMappingURL=go.d.ts.map

package/build/src/backends/go.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go.d.ts","sourceRoot":"","sources":["../../../src/backends/go.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAC,EAHlF;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,sBAAsB,EAAE,cAAc,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,sBAAsB,EAAE,gBAAgB,CAAA;KAAC,EAAE,CAAA;CAGzJ,GAFhF;IAAC,SAAS,EAAE,OAAO,sBAAsB,EAAE,oBAAoB,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CA2C9F"}