semantifold 0.1.0

package/build/src/diagnostic.js

@@ -0,0 +1,96 @@
+// @ts-check
+/** A clear parser, semantic, or backend capability diagnostic. */
+export class SemantifoldDiagnostic extends Error {
+    /**
+     * Creates a diagnostic.
+     * @param {object} options - Diagnostic fields.
+     * @param {string} options.code - Stable diagnostic code.
+     * @param {string} options.message - Human-readable message.
+     * @param {import("./semantic/types.js").SemanticLanguage} options.language - Related language.
+     * @param {import("./semantic/types.js").SourceLocation | undefined} [options.location] - Related location.
+     * @param {import("./semantic/types.js").SourceLocation | undefined} [options.generatedLocation] - Pre-remapping generated location.
+     * @param {Error | undefined} [options.cause] - Preserved parser error.
+     */
+    constructor({ cause, code, generatedLocation, language, location, message }) {
+        const locationText = location ? ` at ${location.filename}:${location.start.line}:${location.start.column}` : "";
+        super(`[${code}] ${language}${locationText}: ${message}`, cause ? { cause } : undefined);
+        this.name = "SemantifoldDiagnostic";
+        this.code = code;
+        this.detail = message;
+        this.generatedLocation = generatedLocation;
+        this.language = language;
+        this.location = location;
+    }
+}
+/**
+ * Throws a normalized parser diagnostic while preserving the parser error.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Frontend language.
+ * @param {unknown} error - Opaque parser error, narrowed immediately.
+ * @returns {never} Always throws.
+ */
+export function parseFailure(language, error) {
+    const cause = error instanceof Error ? error : new Error(String(error));
+    throw new SemantifoldDiagnostic({
+        cause,
+        code: "PARSE_ERROR",
+        language,
+        message: cause.message
+    });
+}
+/**
+ * Throws an unsupported-syntax diagnostic.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Frontend language.
+ * @param {string} syntax - Parser syntax kind.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Source location.
+ * @returns {never} Always throws.
+ */
+export function unsupportedSyntax(language, syntax, location) {
+    throw new SemantifoldDiagnostic({
+        code: "UNSUPPORTED_SYNTAX",
+        language,
+        location,
+        message: `Syntax '${syntax}' is outside the implemented semantic subset.`
+    });
+}
+/**
+ * Throws a missing-type diagnostic.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Frontend language.
+ * @param {string} subject - Untyped subject.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Source location.
+ * @returns {never} Always throws.
+ */
+export function missingType(language, subject, location) {
+    throw new SemantifoldDiagnostic({
+        code: "MISSING_TYPE",
+        language,
+        location,
+        message: `${subject} requires an explicit supported scalar type: integer, boolean, or string.`
+    });
+}
+/**
+ * Throws a language-neutral semantic diagnostic discovered after adaptation.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Source language.
+ * @param {string} code - Stable semantic diagnostic code.
+ * @param {string} detail - Human-readable semantic failure.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Source location.
+ * @returns {never} Always throws.
+ */
+export function semanticFailure(language, code, detail, location) {
+    throw new SemantifoldDiagnostic({ code, language, location, message: detail });
+}
+/**
+ * Throws an unsupported backend-capability diagnostic.
+ * @param {import("./semantic/types.js").SemanticLanguage} language - Backend language.
+ * @param {string} capability - Unsupported semantic capability.
+ * @param {import("./semantic/types.js").SourceLocation | undefined} location - Semantic source location.
+ * @returns {never} Always throws.
+ */
+export function unsupportedCapability(language, capability, location) {
+    throw new SemantifoldDiagnostic({
+        code: "UNSUPPORTED_CAPABILITY",
+        language,
+        location,
+        message: `Backend cannot emit semantic capability '${capability}'.`
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../src/diagnostic.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,kEAAkE;AAClE,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAC9C;;;;;;;;;OASG;IACH,YAAY,EAAC,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAC;QACvE,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,OAAO,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;QAE/G,KAAK,CAAC,IAAI,IAAI,KAAK,QAAQ,GAAG,YAAY,KAAK,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,EAAC,KAAK,EAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;QACtF,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAA;QACnC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAA;QACrB,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;QAC1C,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC1B,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,QAAQ,EAAE,KAAK;IAC1C,MAAM,KAAK,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IAEvE,MAAM,IAAI,qBAAqB,CAAC;QAC9B,KAAK;QACL,IAAI,EAAE,aAAa;QACnB,QAAQ;QACR,OAAO,EAAE,KAAK,CAAC,OAAO;KACvB,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ;IAC1D,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,oBAAoB;QAC1B,QAAQ;QACR,QAAQ;QACR,OAAO,EAAE,WAAW,MAAM,+CAA+C;KAC1E,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ;IACrD,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,cAAc;QACpB,QAAQ;QACR,QAAQ;QACR,OAAO,EAAE,GAAG,OAAO,2EAA2E;KAC/F,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ;IAC9D,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAC,CAAC,CAAA;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ;IAClE,MAAM,IAAI,qBAAqB,CAAC;QAC9B,IAAI,EAAE,wBAAwB;QAC9B,QAAQ;QACR,QAAQ;QACR,OAAO,EAAE,4CAA4C,UAAU,IAAI;KACpE,CAAC,CAAA;AACJ,CAAC","sourcesContent":["// @ts-check\n\n/** A clear parser, semantic, or backend capability diagnostic. */\nexport class SemantifoldDiagnostic extends Error {\n  /**\n   * Creates a diagnostic.\n   * @param {object} options - Diagnostic fields.\n   * @param {string} options.code - Stable diagnostic code.\n   * @param {string} options.message - Human-readable message.\n   * @param {import(\"./semantic/types.js\").SemanticLanguage} options.language - Related language.\n   * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [options.location] - Related location.\n   * @param {import(\"./semantic/types.js\").SourceLocation | undefined} [options.generatedLocation] - Pre-remapping generated location.\n   * @param {Error | undefined} [options.cause] - Preserved parser error.\n   */\n  constructor({cause, code, generatedLocation, language, location, message}) {\n    const locationText = location ? ` at ${location.filename}:${location.start.line}:${location.start.column}` : \"\"\n\n    super(`[${code}] ${language}${locationText}: ${message}`, cause ? {cause} : undefined)\n    this.name = \"SemantifoldDiagnostic\"\n    this.code = code\n    this.detail = message\n    this.generatedLocation = generatedLocation\n    this.language = language\n    this.location = location\n  }\n}\n\n/**\n * Throws a normalized parser diagnostic while preserving the parser error.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {unknown} error - Opaque parser error, narrowed immediately.\n * @returns {never} Always throws.\n */\nexport function parseFailure(language, error) {\n  const cause = error instanceof Error ? error : new Error(String(error))\n\n  throw new SemantifoldDiagnostic({\n    cause,\n    code: \"PARSE_ERROR\",\n    language,\n    message: cause.message\n  })\n}\n\n/**\n * Throws an unsupported-syntax diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {string} syntax - Parser syntax kind.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function unsupportedSyntax(language, syntax, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_SYNTAX\",\n    language,\n    location,\n    message: `Syntax '${syntax}' is outside the implemented semantic subset.`\n  })\n}\n\n/**\n * Throws a missing-type diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Frontend language.\n * @param {string} subject - Untyped subject.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function missingType(language, subject, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"MISSING_TYPE\",\n    language,\n    location,\n    message: `${subject} requires an explicit supported scalar type: integer, boolean, or string.`\n  })\n}\n\n/**\n * Throws a language-neutral semantic diagnostic discovered after adaptation.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Source language.\n * @param {string} code - Stable semantic diagnostic code.\n * @param {string} detail - Human-readable semantic failure.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Source location.\n * @returns {never} Always throws.\n */\nexport function semanticFailure(language, code, detail, location) {\n  throw new SemantifoldDiagnostic({code, language, location, message: detail})\n}\n\n/**\n * Throws an unsupported backend-capability diagnostic.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} language - Backend language.\n * @param {string} capability - Unsupported semantic capability.\n * @param {import(\"./semantic/types.js\").SourceLocation | undefined} location - Semantic source location.\n * @returns {never} Always throws.\n */\nexport function unsupportedCapability(language, capability, location) {\n  throw new SemantifoldDiagnostic({\n    code: \"UNSUPPORTED_CAPABILITY\",\n    language,\n    location,\n    message: `Backend cannot emit semantic capability '${capability}'.`\n  })\n}\n"]}

package/build/src/frontends/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parses supported source into a shared semantic module.
+ * @param {object} input - Parse request.
+ * @param {string} input.filename - Source filename used in diagnostics.
+ * @param {import("../semantic/types.js").SemanticLanguage} input.language - Source language.
+ * @param {string} input.source - Source text.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export declare function parseSource({ filename, language, source }: {
+    filename: string;
+    language: import("../semantic/types.js").SemanticLanguage;
+    source: string;
+}): import("../semantic/types.js").SemanticModule;
+//# sourceMappingURL=index.d.ts.map

package/build/src/frontends/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontends/index.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAC,EALrD;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAA+D,QAAQ,EAA/D,OAAO,sBAAsB,EAAE,gBAAgB,CACvD;IAAsB,MAAM,EAApB,MAAM,CACd;CAEqD,GAF3C,OAAO,sBAAsB,EAAE,cAAc,CAmBzD"}

package/build/src/frontends/index.js

@@ -0,0 +1,36 @@
+// @ts-check
+import { SemantifoldDiagnostic } from "../diagnostic.js";
+import { annotateParsedModule } from "../semantic/provenance.js";
+import { validateParsedModule } from "../semantic/validate.js";
+import { parseJava } from "./java.js";
+import { parseJavaScriptTypeScript } from "./javascript-typescript.js";
+import { parsePhp } from "./php.js";
+import { parseRuby } from "./ruby.js";
+/**
+ * Parses supported source into a shared semantic module.
+ * @param {object} input - Parse request.
+ * @param {string} input.filename - Source filename used in diagnostics.
+ * @param {import("../semantic/types.js").SemanticLanguage} input.language - Source language.
+ * @param {string} input.source - Source text.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export function parseSource({ filename, language, source }) {
+    let module;
+    if (language == "php")
+        module = validateParsedModule(parsePhp({ filename, source }), language);
+    else if (language == "ruby")
+        module = validateParsedModule(parseRuby({ filename, source }), language);
+    if (language == "javascript" || language == "typescript") {
+        module = validateParsedModule(parseJavaScriptTypeScript({ filename, language, source }), language);
+    }
+    else if (language == "java")
+        module = validateParsedModule(parseJava({ filename, source }), language);
+    if (module)
+        return annotateParsedModule(module, { filename, language, source });
+    throw new SemantifoldDiagnostic({
+        code: "UNSUPPORTED_LANGUAGE",
+        language,
+        message: "No frontend adapter is registered for this language."
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/frontends/java.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses Java into the shared semantic module.
+ * @param {object} input - Parser input.
+ * @param {string} input.filename - Source filename.
+ * @param {string} input.source - Source text.
+ * @returns {import("../semantic/types.js").SemanticModule} Semantic module.
+ */
+export declare function parseJava({ filename, source }: {
+    filename: string;
+    source: string;
+}): import("../semantic/types.js").SemanticModule;
+//# sourceMappingURL=java.d.ts.map

package/build/src/frontends/java.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../../src/frontends/java.js"],"names":[],"mappings":"AA8rBA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAC,EAJzC;IAAsB,QAAQ,EAAtB,MAAM,CACd;IAAsB,MAAM,EAApB,MAAM,CACd;CAEyC,GAF/B,OAAO,sBAAsB,EAAE,cAAc,CA2BzD"}