lemmascript 0.3.3 → 0.5.0

package/tools/dist/types.js

@@ -4,81 +4,140 @@
  * Single source of truth for type-related decisions.
  * The transform phase imports this.
  */
-/** Split generic type arguments respecting nested angle brackets. */
-function splitTypeArgs(s) {
-    const args = [];
-    let depth = 0, start = 0;
-    for (let i = 0; i < s.length; i++) {
-        if (s[i] === '<')
-            depth++;
-        else if (s[i] === '>')
-            depth--;
-        else if (s[i] === ',' && depth === 0) {
-            args.push(s.slice(start, i));
-            start = i + 1;
-        }
-    }
-    args.push(s.slice(start));
-    return args.map(a => a.trim());
+import { Node, Project, SyntaxKind } from "ts-morph";
+/**
+ * Parses TS type strings via a real ts-morph parse — no regex cascade. Set
+ * once per run by `extractModule` (so it reuses the module's Project); a
+ * separate in-memory Project is created lazily for callers that hit
+ * `parseTsType` outside the extract pipeline (e.g. tests, `lsc info` when
+ * driven independently).
+ */
+let _synthFile = null;
+export function initTypeParser(project) {
+    _synthFile = project.createSourceFile("__lsc_type_parse__.ts", "", { overwrite: true });
+}
+function synthFile() {
+    if (_synthFile)
+        return _synthFile;
+    const p = new Project({ useInMemoryFileSystem: true });
+    _synthFile = p.createSourceFile("__lsc_type_parse__.ts", "");
+    return _synthFile;
 }
 export function parseTsType(tsType) {
-    const t = tsType.trim();
-    // Union: T | undefined → optional<T>
-    if (t.includes(" | ")) {
-        let arms = t.split(" | ").map(a => a.trim());
-        // Normalize expanded boolean literals: true | false → boolean
-        const boolLits = new Set(["true", "false"]);
-        const hasBoth = arms.includes("true") && arms.includes("false");
-        if (hasBoth) {
-            arms = arms.filter(a => !boolLits.has(a));
-            arms.unshift("boolean");
+    const sf = synthFile();
+    sf.replaceWithText(`type __t = ${tsType};`);
+    const alias = sf.getTypeAliasOrThrow("__t");
+    return tyFromTypeNode(alias.getTypeNodeOrThrow());
+}
+function tyFromTypeNode(tn) {
+    if (Node.isParenthesizedTypeNode(tn))
+        return tyFromTypeNode(tn.getTypeNode());
+    if (Node.isUnionTypeNode(tn)) {
+        const arms = tn.getTypeNodes();
+        const isBoolLit = (a) => Node.isLiteralTypeNode(a) && (a.getLiteral().getKind() === SyntaxKind.TrueKeyword || a.getLiteral().getKind() === SyntaxKind.FalseKeyword);
+        const isNullish = (a) => a.getKind() === SyntaxKind.NullKeyword ||
+            a.getKind() === SyntaxKind.UndefinedKeyword ||
+            (Node.isLiteralTypeNode(a) && a.getLiteral().getKind() === SyntaxKind.NullKeyword);
+        // Collapse expanded boolean (`true | false`) into a single bool slot, so
+        // `boolean | undefined` (which TS expands to `false | true | undefined`)
+        // still reads as `optional<bool>` rather than falling through to user.
+        const hasTrueLit = arms.some(a => Node.isLiteralTypeNode(a) && a.getLiteral().getKind() === SyntaxKind.TrueKeyword);
+        const hasFalseLit = arms.some(a => Node.isLiteralTypeNode(a) && a.getLiteral().getKind() === SyntaxKind.FalseKeyword);
+        const collapseBool = hasTrueLit && hasFalseLit;
+        const normalized = collapseBool
+            ? [{ syntheticBool: true }, ...arms.filter(a => !isBoolLit(a)).map(node => ({ node }))]
+            : arms.map(node => ({ node }));
+        if (normalized.length === 1 && "syntheticBool" in normalized[0])
+            return { kind: "bool" };
+        const nonNullish = normalized.filter(a => "syntheticBool" in a || !isNullish(a.node));
+        if (nonNullish.length === 1 && normalized.length >= 2) {
+            const sole = nonNullish[0];
+            const inner = "syntheticBool" in sole ? { kind: "bool" } : tyFromTypeNode(sole.node);
+            return { kind: "optional", inner };
         }
-        const nonUndef = arms.filter(a => a !== "undefined");
-        if (nonUndef.length === 1 && arms.length === 2) {
-            return { kind: "optional", inner: parseTsType(nonUndef[0]) };
+        // Multi-member union with a nullish arm (`A | B | undefined`): the
+        // structured part is opaque to us, but the optionality isn't. Expose it as
+        // optional<user "A | B"> so downstream (e.g. the let-type merge in resolve)
+        // can keep the nullability while taking structure from a more precise
+        // source. Without this the whole thing collapses to one opaque user blob.
+        const hadNullish = normalized.some(a => !("syntheticBool" in a) && isNullish(a.node));
+        if (hadNullish && nonNullish.length >= 2) {
+            const innerName = nonNullish.map(a => ("syntheticBool" in a ? "boolean" : a.node.getText())).join(" | ");
+            return { kind: "optional", inner: { kind: "user", name: innerName } };
         }
+        // Other unions: leave as a user type spelled how the source wrote it.
+        return { kind: "user", name: tn.getText() };
     }
-    if (t === "number")
-        return { kind: "int" };
-    if (t === "bigint")
-        return { kind: "int" };
-    if (t === "nat")
-        return { kind: "nat" };
-    if (t === "boolean" || t === "true" || t === "false")
-        return { kind: "bool" };
-    if (t === "string")
-        return { kind: "string" };
-    if (t === "void" || t === "undefined")
-        return { kind: "void" };
-    if (t === "unknown")
-        return { kind: "unknown" };
-    // Record<K, V> → map
-    const recordMatch = t.match(/^Record<(.+)>$/);
-    if (recordMatch) {
-        const args = splitTypeArgs(recordMatch[1]);
-        if (args.length === 2)
-            return { kind: "map", key: parseTsType(args[0]), value: parseTsType(args[1]) };
+    if (Node.isArrayTypeNode(tn))
+        return { kind: "array", elem: tyFromTypeNode(tn.getElementTypeNode()) };
+    if (Node.isTupleTypeNode(tn)) {
+        const elems = tn.getElements();
+        if (elems.length === 0)
+            return { kind: "array", elem: { kind: "unknown" } };
+        return { kind: "array", elem: tyFromTypeNode(elems[0]) };
     }
-    // Array<T> or T[]
-    const m = t.match(/^(?:Array<(.+)>|(.+)\[\])$/);
-    if (m)
-        return { kind: "array", elem: parseTsType(m[1] || m[2]) };
-    // Map<K, V>
-    const mapMatch = t.match(/^Map<(.+)>$/);
-    if (mapMatch) {
-        const args = splitTypeArgs(mapMatch[1]);
-        if (args.length === 2)
-            return { kind: "map", key: parseTsType(args[0]), value: parseTsType(args[1]) };
+    if (Node.isFunctionTypeNode(tn)) {
+        const params = tn.getParameters().map(p => {
+            const ptn = p.getTypeNode();
+            return ptn ? tyFromTypeNode(ptn) : { kind: "unknown" };
+        });
+        const result = tyFromTypeNode(tn.getReturnTypeNodeOrThrow());
+        return { kind: "fn", params, result };
     }
-    // Set<T>
-    const setMatch = t.match(/^Set<(.+)>$/);
-    if (setMatch)
-        return { kind: "set", elem: parseTsType(setMatch[1]) };
-    // Tuple [T1, T2, ...] → array of the common element type
-    const tupleMatch = t.match(/^\[(.+)\]$/);
-    if (tupleMatch) {
-        const elems = splitTypeArgs(tupleMatch[1]);
-        return { kind: "array", elem: parseTsType(elems[0]) };
+    if (Node.isLiteralTypeNode(tn)) {
+        const lk = tn.getLiteral().getKind();
+        if (lk === SyntaxKind.TrueKeyword || lk === SyntaxKind.FalseKeyword)
+            return { kind: "bool" };
+    }
+    switch (tn.getKind()) {
+        case SyntaxKind.NumberKeyword:
+        case SyntaxKind.BigIntKeyword:
+            return { kind: "int" };
+        case SyntaxKind.BooleanKeyword:
+            return { kind: "bool" };
+        case SyntaxKind.StringKeyword:
+            return { kind: "string" };
+        case SyntaxKind.VoidKeyword:
+        case SyntaxKind.UndefinedKeyword:
+            return { kind: "void" };
+        case SyntaxKind.UnknownKeyword:
+        case SyntaxKind.AnyKeyword:
+            return { kind: "unknown" };
+    }
+    if (Node.isTypeReference(tn)) {
+        const name = tn.getTypeName().getText();
+        const args = tn.getTypeArguments();
+        if (name === "nat" && args.length === 0)
+            return { kind: "nat" };
+        if (name === "Array" && args.length === 1)
+            return { kind: "array", elem: tyFromTypeNode(args[0]) };
+        if (name === "Set" && args.length === 1)
+            return { kind: "set", elem: tyFromTypeNode(args[0]) };
+        if ((name === "Map" || name === "Record") && args.length === 2) {
+            return { kind: "map", key: tyFromTypeNode(args[0]), value: tyFromTypeNode(args[1]) };
+        }
+        // User-named type: include generic args in the spelled name so callers
+        // that key on the string (e.g. typedir alias lookups) see the exact form.
+        return { kind: "user", name: tn.getText() };
+    }
+    return { kind: "user", name: tn.getText() };
+}
+/** Render a Ty in LemmaScript canonical syntax — backend-neutral, side-effect-free.
+ *  Used by `lsc info` for the signature field of `foo.ts.json`. */
+export function tyToCanonical(ty) {
+    switch (ty.kind) {
+        case "bool": return "bool";
+        case "nat": return "nat";
+        case "int": return "int";
+        case "real": return "real";
+        case "string": return "string";
+        case "void": return "void";
+        case "unknown": return "unknown";
+        case "array": return `seq<${tyToCanonical(ty.elem)}>`;
+        case "map": return `map<${tyToCanonical(ty.key)}, ${tyToCanonical(ty.value)}>`;
+        case "set": return `set<${tyToCanonical(ty.elem)}>`;
+        case "optional": return `Option<${tyToCanonical(ty.inner)}>`;
+        case "user": return ty.name;
+        case "fn": return `(${ty.params.map(tyToCanonical).join(", ")}) -> ${tyToCanonical(ty.result)}`;
     }
-    return { kind: "user", name: t };
 }