semantifold 0.3.0 → 0.4.0

package/src/backends/go.js

@@ -98,7 +98,12 @@ function validateLocalReads(module) {
         declarations.push(statement)
         collectIdentifierReads(statement.initializer, reads)
       } else if (statement.kind == "IfStatement") collectIdentifierReads(statement.condition, reads)
-      else collectIdentifierReads(statement.expression, reads)
+      else if (statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" ||
+        statement.kind == "PrintStatement" || statement.kind == "ReturnStatement") {
+        const expression = statement.expression
+
+        if (expression) collectIdentifierReads(expression, reads)
+      }
     })
     for (const declaration of declarations) {
       if (!reads.has(declaration.name)) {
@@ -243,16 +248,23 @@ function emitStatement(writer, statement, indent, path) {
     return emitLocal(writer, statement, indent, path)
   }
   if (statement.kind == "IfStatement") return emitIf(writer, statement, indent, path, true)
+  if (statement.kind == "ExpressionStatement") throw new TypeError("Go Task 005 expression statement reached emission.")
+  if (statement.kind == "BreakStatement" || statement.kind == "ContinueStatement" || statement.kind == "ForEachStatement") {
+    throw new TypeError("Unsupported Go statement reached emission.")
+  }
   writer.synthetic(indent, "indentation", [statement], [path])
   if (statement.kind == "ReturnStatement") {
+    if (!statement.expression) throw new TypeError("Go bare return reached emission.")
     writer.mapped("return", {mappingKind: "anchor", node: statement, path})
     writer.synthetic(" ", "return spacing", [statement], [path])
     emitExpression(writer, statement.expression, path + "/expression", "go", identity)
-  } else {
+  } else if (statement.kind == "PrintStatement") {
     writer.mapped("fmt.Println", {mappingKind: "anchor", node: statement, path})
     writer.mapped("(", {mappingKind: "anchor", node: statement, path})
     emitExpression(writer, statement.expression, path + "/expression", "go", identity)
     writer.mapped(")", {mappingKind: "anchor", node: statement, path})
+  } else {
+    throw new TypeError("Unsupported Go statement reached emission after preflight.")
   }
   writer.synthetic("\n", "line break", [statement], [path])
 }

package/src/backends/identifiers.js

@@ -2,8 +2,12 @@
 
 import {unsupportedCapability} from "../diagnostic.js"
 
-/** @type {Record<import("../semantic/types.js").SemanticLanguage, RegExp>} */
+/** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios">, RegExp>} */
 const identifierPatterns = {
+  dart: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
+  kotlin: /^(?:_|\p{L})(?:_|\p{L}|\p{Nd})*$/u,
+  swift: /^(?:_|\p{XID_Start})(?:_|\p{XID_Continue})*$/u,
+  rust: /^[A-Za-z_][A-Za-z0-9_]*$/u,
   cpp: /^[A-Za-z][A-Za-z0-9_]*$/u,
   c: /^[A-Za-z][A-Za-z0-9_]*$/u,
   csharp: /^[A-Za-z_][A-Za-z0-9_]*$/u,
@@ -13,11 +17,43 @@ const identifierPatterns = {
   php: /^[A-Za-z_][A-Za-z0-9_]*$/u,
   python: /^(?:_|\p{XID_Start})(?:_|\p{XID_Continue})*$/u,
   ruby: /^[a-z_][A-Za-z0-9_]*$/u,
-  typescript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u
+  typescript: /^[A-Za-z_$][A-Za-z0-9_$]*$/u,
+  wasm: /^(?:[$_]|\p{XID_Start})(?:[$_]|\p{XID_Continue})*$/u
 }
 
-/** @type {Record<import("../semantic/types.js").SemanticLanguage, Set<string>>} */
+/** @type {Record<Exclude<import("../semantic/types.js").BackendLanguage, "ios">, Set<string>>} */
 const reservedWords = {
+  dart: new Set([
+    "Function", "Never", "Object", "RangeError", "String", "abstract", "as", "assert", "async", "await", "base",
+    "bool", "break", "case", "catch", "class", "const", "continue", "covariant", "default", "deferred", "do",
+    "double", "dynamic", "else", "enum", "export", "extends", "extension", "external", "factory", "false", "final",
+    "finally", "for", "get", "hide", "if", "implements", "import", "in", "int", "interface", "is", "late", "library",
+    "main", "mixin", "native", "new", "null", "num", "of", "on", "operator", "part", "print", "required", "rethrow",
+    "return", "sealed", "set", "show", "static", "super", "switch", "sync", "this", "throw", "true", "try", "typedef",
+    "var", "void", "when", "while", "with", "yield", "BigInt", "_"
+  ]),
+  kotlin: new Set([
+    "as", "break", "class", "continue", "do", "else", "false", "for", "fun", "if", "in", "interface", "is", "null",
+    "object", "package", "return", "super", "this", "throw", "true", "try", "typealias", "typeof", "val", "var", "when",
+    "while", "_", "main", "println", "Long", "Boolean", "String", "Math", "ArithmeticException"
+  ]),
+  swift: new Set([
+    "Any", "Self", "Type", "Protocol", "actor", "any", "as", "associatedtype", "associativity", "async", "await", "borrowing",
+    "break", "case", "catch", "class", "consume", "consuming", "continue", "convenience", "copy", "default", "defer", "deinit",
+    "didSet", "distributed", "do", "dynamic", "else", "enum", "extension", "fallthrough", "false", "fileprivate", "final", "for",
+    "func", "get", "guard", "if", "import", "in", "indirect", "infix", "init", "inout", "internal", "is", "isolated", "lazy",
+    "let", "macro", "mutating", "nil", "nonisolated", "nonmutating", "open", "operator", "optional", "override", "package",
+    "postfix", "precedence", "precedencegroup", "prefix", "private", "protocol", "public", "repeat", "required", "rethrows", "return",
+    "safe", "self", "sending", "set", "some", "static", "struct", "subscript", "super", "switch", "throws", "true", "try",
+    "typealias", "unowned", "unsafe", "var", "weak", "where", "while", "willSet", "yield", "_", "Bool", "Int", "Int64", "String",
+    "Swift", "main", "print"
+  ]),
+  rust: new Set([
+    "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum", "extern", "false", "fn", "for", "if", "impl", "in",
+    "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "type",
+    "unsafe", "use", "where", "while", "abstract", "become", "box", "do", "final", "macro", "override", "priv", "typeof", "unsized", "virtual",
+    "yield", "try", "union", "_", "main", "String", "std", "i64", "bool"
+  ]),
   cpp: new Set([
     "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand", "bitor", "bool", "break", "case", "catch", "char", "char8_t", "char16_t", "char32_t", "class", "compl", "concept", "const", "consteval", "constexpr", "constinit", "const_cast", "continue", "co_await", "co_return", "co_yield", "decltype", "default", "delete", "do", "double", "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", "float", "for", "friend", "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", "requires", "return", "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch", "template", "this", "thread_local", "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq", "std", "string", "numeric_limits",
     // The qualified libstdc++ <string> include chain also exposes these global names.
@@ -108,7 +144,8 @@ const reservedWords = {
     "override", "package", "private", "protected", "public", "readonly", "require", "return", "satisfies", "set",
     "static", "string", "super", "switch", "symbol", "this", "throw", "true", "try", "type", "typeof", "undefined",
     "unique", "unknown", "using", "var", "void", "while", "with", "yield"
-  ])
+  ]),
+  wasm: new Set()
 }
 
 const phpInvalidParameterBindings = new Set([
@@ -116,9 +153,61 @@ const phpInvalidParameterBindings = new Set([
 ])
 const phpInvalidAssignedBindings = new Set(["GLOBALS", "this"])
 
+/** @type {Readonly<Partial<Record<import("../semantic/types.js").BackendLanguage, Set<string>>>>} */
+const reservedTypeNames = Object.freeze({
+  java: new Set(["Boolean", "Integer", "Main", "Math", "Object", "String", "System"]),
+  javascript: new Set(["Array", "Boolean", "Map", "Math", "Number", "Object", "Reflect", "String"]),
+  php: new Set([
+    "addressinfo", "allowdynamicproperties", "appenditerator", "argumentcounterror", "arithmeticerror", "arrayaccess",
+    "arrayiterator", "arrayobject", "assertionerror", "attribute", "backedenum", "badfunctioncallexception",
+    "badmethodcallexception", "cachingiterator",
+    "callbackfilteriterator", "closedgeneratorexception", "closure", "compileerror", "countable", "dateerror", "dateexception",
+    "dateinterval", "dateinvalidoperationexception", "dateinvalidtimezoneexception", "datemalformedintervalstringexception",
+    "datemalformedperiodstringexception", "datemalformedstringexception", "dateobjecterror", "dateperiod", "daterangeerror",
+    "datetime", "datetimeimmutable", "datetimeinterface", "datetimezone", "deflatecontext", "delayedtargetvalidation",
+    "deprecated", "directory", "directoryiterator", "divisionbyzeroerror", "domainexception", "emptyiterator", "error",
+    "errorexception", "exception", "ffi", "fiber", "fibererror", "filesystemiterator", "filteriterator", "finfo", "generator",
+    "globiterator", "hashcontext", "infiniteiterator", "inflatecontext", "internaliterator", "invalidargumentexception",
+    "iterator", "iteratoraggregate", "iteratoriterator", "jsonexception", "jsonserializable", "lengthexception",
+    "libxmlerror", "limititerator", "logicexception", "multipleiterator", "nodiscard", "norewinditerator",
+    "opensslasymmetrickey", "opensslcertificate", "opensslcertificatesigningrequest",
+    "outofboundsexception", "outofrangeexception", "outeriterator", "overflowexception", "override", "parentiterator",
+    "parseerror", "pdo", "pdoexception", "pdorow", "pdostatement", "phar", "phardata", "pharexception", "pharfileinfo",
+    "php_user_filter", "phptoken", "propertyhooktype", "rangeexception", "recursivearrayiterator", "recursivecachingiterator",
+    "recursivecallbackfilteriterator",
+    "recursivedirectoryiterator", "recursivefilteriterator", "recursiveiterator", "recursiveiteratoriterator",
+    "recursiveregexiterator", "recursivetreeiterator", "reflection", "reflectionattribute", "reflectionclass",
+    "reflectionclassconstant", "reflectionconstant", "reflectionenum", "reflectionenumbackedcase", "reflectionenumunitcase",
+    "reflectionexception", "reflectionextension", "reflectionfiber", "reflectionfunction", "reflectionfunctionabstract",
+    "reflectiongenerator", "reflectionintersectiontype", "reflectionmethod", "reflectionnamedtype", "reflectionobject",
+    "reflectionparameter", "reflectionproperty", "reflectionreference", "reflectiontype", "reflectionuniontype",
+    "reflectionzendextension", "reflector", "regexiterator", "requestparsebodyexception", "returntypewillchange",
+    "roundingmode", "runtimeexception", "seekableiterator", "sensitiveparameter", "sensitiveparametervalue", "serializable",
+    "sessionhandler", "sessionhandlerinterface", "sessionidinterface", "sessionupdatetimestamphandlerinterface", "shmop",
+    "socket", "sodiumexception", "spldoublylinkedlist", "splfileinfo",
+    "splfileobject", "splfixedarray", "splheap", "splmaxheap", "splminheap", "splobjectstorage", "splobserver",
+    "splpriorityqueue", "splqueue", "splstack", "splsubject", "spltempfileobject", "stdclass", "streambucket", "stringable",
+    "sysvmessagequeue", "sysvsemaphore", "sysvsharedmemory", "throwable", "traversable", "typeerror", "underflowexception",
+    "unexpectedvalueexception", "unhandledmatcherror", "unitenum", "valueerror", "weakmap", "weakreference"
+  ]),
+  ruby: new Set([
+    "ArgumentError", "Array", "BasicObject", "Binding", "Class", "ClosedQueueError", "Comparable", "Complex", "Data", "Dir",
+    "Encoding", "EncodingError", "Enumerable", "Enumerator", "EOFError", "Errno", "Exception", "FalseClass", "Fiber",
+    "FiberError", "File", "FileTest", "Float", "FrozenError", "GC", "Hash", "IO", "IOError", "IndexError", "Integer",
+    "Interrupt", "Kernel", "KeyError", "LoadError", "LocalJumpError", "Marshal", "MatchData", "Math", "Method", "Module",
+    "Mutex", "NameError", "NilClass", "NoMemoryError", "NoMethodError", "NotImplementedError", "Numeric", "Object",
+    "ObjectSpace", "Proc", "Process", "Queue", "Ractor", "Random", "Range", "Rational", "Regexp", "RegexpError", "RubyVM",
+    "RuntimeError", "ScriptError", "SecurityError", "Signal", "SignalException", "SizedQueue", "StandardError", "StopIteration",
+    "String", "Struct", "Symbol", "SyntaxError", "SystemCallError", "SystemExit", "SystemStackError", "Thread", "ThreadError",
+    "ThreadGroup", "Time", "TracePoint", "TrueClass", "TypeError", "UnboundMethod", "UncaughtThrowError", "Warning",
+    "ZeroDivisionError"
+  ]),
+  typescript: new Set(["Array", "Boolean", "Map", "Math", "Number", "Object", "ReadonlyArray", "ReadonlyMap", "Reflect", "String"])
+})
+
 /**
  * Validates an identifier against the target backend's deliberately narrow lexical contract.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
  * @param {unknown} name - Candidate semantic identifier.
  * @param {string} role - Identifier role for diagnostics.
  * @param {import("../semantic/types.js").SourceLocation | undefined} location - Originating location.
@@ -128,11 +217,16 @@ export function validateTargetIdentifier(language, name, role, location) {
   if (typeof name != "string") unsupportedCapability(language, `${role} identifier`, location)
 
   const reservedName = language == "php" ? name.toLowerCase() : name
+  const syntaxLanguage = language == "ios" ? "swift" : language
 
-  if (!identifierPatterns[language].test(name) || reservedWords[language].has(reservedName) ||
+  if (!identifierPatterns[syntaxLanguage].test(name) || reservedWords[syntaxLanguage].has(reservedName) ||
     language == "python" && name.normalize("NFKC") != name ||
     language == "c" && !isCIdentifier(name) ||
-    language == "cpp" && !isCppIdentifier(name)) {
+    language == "rust" && !isRustIdentifier(name) ||
+    language == "cpp" && !isCppIdentifier(name) ||
+    language == "dart" && !isDartIdentifier(name) ||
+    language == "swift" && (!isSwiftIdentifier(name) || name.normalize("NFC") != name) ||
+    language == "kotlin" && (!isKotlinIdentifier(name) || name.normalize("NFC") != name)) {
     unsupportedCapability(language, `${role} identifier '${name}'`, location)
   }
 }
@@ -150,7 +244,7 @@ export function isCIdentifier(name) {
 
 /**
  * Validates a binding identifier against target restrictions beyond general identifier syntax.
- * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
  * @param {unknown} name - Candidate semantic identifier.
  * @param {string} role - Binding role for diagnostics.
  * @param {import("../semantic/types.js").SourceLocation | undefined} location - Originating location.
@@ -162,7 +256,7 @@ export function validateTargetBindingIdentifier(language, name, role, location)
   const invalidTypeScriptBinding = language == "typescript" && (name == "arguments" || name == "eval")
   const invalidPhpVariable = language == "php" && typeof name == "string" &&
     ((role == "parameter" && phpInvalidParameterBindings.has(name)) ||
-      ((role == "local" || role == "assignment target") && phpInvalidAssignedBindings.has(name)))
+      ((role == "local" || role == "assignment target" || role == "catch binding") && phpInvalidAssignedBindings.has(name)))
   const invalidRubyBinding = language == "ruby" && typeof name == "string" && /^_[1-9]$/u.test(name)
 
   if (invalidTypeScriptBinding || invalidPhpVariable || invalidRubyBinding) {
@@ -170,6 +264,25 @@ export function validateTargetBindingIdentifier(language, name, role, location)
   }
 }
 
+/**
+ * Validates a nominal record/type declaration name for the original-five targets.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Backend language.
+ * @param {unknown} name - Candidate type name.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Declaration location.
+ * @returns {void}
+ */
+export function validateTargetTypeIdentifier(language, name, location) {
+  if (typeof name != "string" || !/^[A-Z][A-Za-z0-9_]*$/u.test(name)) {
+    unsupportedCapability(language, `record type identifier '${String(name)}'`, location)
+  }
+  const reservedName = language == "php" ? name.toLowerCase() : name
+  const syntaxLanguage = language == "ios" ? "swift" : language
+
+  if (reservedWords[syntaxLanguage].has(reservedName) || reservedTypeNames[language]?.has(reservedName)) {
+    unsupportedCapability(language, `record type identifier '${name}'`, location)
+  }
+}
+
 /**
  * Protects C++ keywords, the actual included C library names/macros and the scaffold namespace.
  * @param {string} name - Caller scalar binding or function name.
@@ -178,3 +291,41 @@ export function validateTargetBindingIdentifier(language, name, role, location)
 export function isCppIdentifier(name) {
   return isCIdentifier(name) && !name.includes("__") && !reservedWords.cpp.has(name)
 }
+
+/**
+ * Protects the edition-2021 scalar, entry and exact helper environment in both directions.
+ * @param {string} name - Caller-owned function or binding name.
+ * @returns {boolean} Whether ordinary Rust syntax can represent the name safely.
+ */
+export function isRustIdentifier(name) {
+  return identifierPatterns.rust.test(name) && !reservedWords.rust.has(name) && !name.startsWith("semantifold_")
+}
+
+/**
+ * Protects Swift keywords, scalar names, entry plumbing, and target-only helper names.
+ * @param {string} name - Caller-owned function or binding name.
+ * @returns {boolean} Whether ordinary unescaped Swift syntax can preserve the name.
+ */
+export function isSwiftIdentifier(name) {
+  return identifierPatterns.swift.test(name) && !reservedWords.swift.has(name) && !name.startsWith("semantifold_")
+}
+
+/**
+ * Protects Kotlin keywords, JVM scalar/scaffold names, and target-only helper names.
+ * @param {string} name - Caller-owned function or binding name.
+ * @returns {boolean} Whether ordinary unescaped Kotlin syntax can preserve the name.
+ */
+export function isKotlinIdentifier(name) {
+  return identifierPatterns.kotlin.test(name) && !reservedWords.kotlin.has(name) && !name.startsWith("semantifold_") &&
+    !name.startsWith("SEMANTIFOLD_")
+}
+
+/**
+ * Protects Dart keywords, VM scalar/scaffold names, and compiler-owned helpers.
+ * @param {string} name - Caller-owned function or binding name.
+ * @returns {boolean} Whether ordinary Dart syntax can preserve the name.
+ */
+export function isDartIdentifier(name) {
+  return identifierPatterns.dart.test(name) && !reservedWords.dart.has(name) &&
+    !name.startsWith("_semantifold") && name.normalize("NFC") == name
+}

package/src/backends/index.js

@@ -7,6 +7,7 @@ import {validateNativeGraph} from "./native-validation.js"
 import {validateBackendModule} from "./shared.js"
 import {SourceWriter} from "./writer.js"
 import {finalizeMapping, toSourceMapV3} from "../mapping.js"
+import {preflightEffectCapabilities} from "./effects.js"
 const syntheticArtifactBase = Object.freeze(["__semantifold_artifacts__"])
 
 /**
@@ -38,12 +39,30 @@ export function generateArtifactSource({language, filename, mapDirective = "none
   if (record.artifactMultiplicity != "single") unsupportedRole(language, "single-text backend", module?.location)
   if (filename === undefined) filename = record.defaultFilename
   if (sourceMapFilename === undefined) sourceMapFilename = `${filename}.map`
-  if (language == "cpp") validateNativeGraph(module, "cpp")
-  validateBackendModule(module, language)
+  const genericDeclaration = [...module?.records ?? [], ...module?.functions ?? []]
+    .find((declaration) => (declaration?.typeParameters?.length ?? 0) > 0)
+
+  if (genericDeclaration && !record.features.typeParametersAndGenerics) {
+    unsupportedCapability(/** @type {import("../semantic/types.js").BackendLanguage} */ (language),
+      "Task 012 type parameters and generics", genericDeclaration.location ?? module.location)
+  }
+  if (Array.isArray(module?.records) && module.records.length > 0 && !record.features.closedRecords) {
+    unsupportedCapability(/** @type {import("../semantic/types.js").BackendLanguage} */ (language),
+      "Task 009 closed records", module.records[0].location ?? module.location)
+  }
+  preflightEffectCapabilities(module, /** @type {import("../semantic/types.js").BackendLanguage} */ (language))
+  if (language == "cpp" || language == "kotlin" || language == "swift") validateNativeGraph(module, language)
+  validateBackendModule(module, /** @type {import("../semantic/types.js").BackendLanguage} */ (language))
 
   if (language == "cpp" && (mapDirective != "none" || sourceMapFilename != "program.cpp.map")) {
     unsupportedCapability(language, "CPP map directive or alternate source-map filename", module.location)
   }
+  if (language == "swift" && (mapDirective != "none" || sourceMapFilename != "program.swift.map")) {
+    unsupportedCapability(language, "Swift map directive or alternate source-map filename", module.location)
+  }
+  if (language == "kotlin" && (mapDirective != "none" || sourceMapFilename != "Program.kt.map")) {
+    unsupportedCapability(language, "Kotlin map directive or alternate source-map filename", module.location)
+  }
 
   if (!isValidFilenameMetadata(filename)) {
     throw new TypeError("Generated filename must be a non-empty single-line string.")
@@ -52,6 +71,8 @@ export function generateArtifactSource({language, filename, mapDirective = "none
     throw new TypeError("Source map filename must be a non-empty single-line string.")
   }
   if (language == "cpp" && filename != "program.cpp") unsupportedCapability(language, "artifact filename other than program.cpp", module.location)
+  if (language == "swift" && filename != "program.swift") unsupportedCapability(language, "artifact filename other than program.swift", module.location)
+  if (language == "kotlin" && filename != "Program.kt") unsupportedCapability(language, "artifact filename other than Program.kt", module.location)
   if (language == "java" && filename.split(/[\\/]/u).at(-1) != "Main.java") {
     unsupportedCapability(language, "artifact filename basename other than Main.java", module.location)
   }
@@ -81,6 +102,10 @@ export function generateArtifactSource({language, filename, mapDirective = "none
 
   const mapping = finalizeMapping(writer.finish())
 
+  if (language == "swift" || language == "kotlin") {
+    languageRegistry.resolve(language, "frontend", module.location)({filename, source: mapping.generated.content})
+  }
+
   return {
     code: mapping.generated.content,
     filename,