@tsonic/emitter 0.0.73 → 0.0.74

package/dist/expressions/calls/call-emitter.js

@@ -7,10 +7,11 @@ import { emitTypeArgumentsAst, generateSpecializedName, } from "../identifiers.j
 import { emitTypeAst } from "../../type-emitter.js";
 import { emitMemberAccess } from "../access.js";
 import { isLValue, getPassingModifierFromCast, isJsonSerializerCall, isGlobalJsonCall, isInstanceMemberAccess, shouldEmitFluentExtensionCall, getTypeNamespace, registerJsonAotExpressionTypes, registerJsonAotType, needsIntCast, isPromiseChainMethod, isAsyncWrapperType, } from "./call-analysis.js";
-import { extractCalleeNameFromAst } from "../../core/format/backend-ast/utils.js";
+import { extractCalleeNameFromAst, getIdentifierTypeLeafName, } from "../../core/format/backend-ast/utils.js";
 import { resolveImportPath } from "../../core/semantic/index.js";
 import { containsTypeParameter } from "../../core/semantic/type-resolution.js";
 import { allocateLocalName } from "../../core/format/local-names.js";
+import { identifierExpression, identifierType, nullLiteral, stringLiteral, } from "../../core/format/backend-ast/builders.js";
 /**
  * Wrap an expression AST with an optional argument modifier (ref/out/in).
  */
@@ -94,6 +95,9 @@ const captureAssignableArrayTarget = (expr, context) => {
             kind: "identifierExpression",
             identifier: indexTemp.emittedName,
         };
+        const indexArgument = receiverAst.arguments[0];
+        if (!indexArgument)
+            return undefined;
         return {
             readExpression: {
                 kind: "elementAccessExpression",
@@ -107,7 +111,7 @@ const captureAssignableArrayTarget = (expr, context) => {
             },
             setupStatements: [
                 createVarLocal(objectTemp.emittedName, receiverAst.expression),
-                createVarLocal(indexTemp.emittedName, receiverAst.arguments[0]),
+                createVarLocal(indexTemp.emittedName, indexArgument),
             ],
             context: indexTemp.context,
         };
@@ -199,11 +203,9 @@ const emitArrayMutationInteropCall = (expr, context) => {
                 ...captured.setupStatements,
                 createVarLocal(wrapperTemp.emittedName, {
                     kind: "objectCreationExpression",
-                    type: {
-                        kind: "identifierType",
-                        name: "global::Tsonic.JSRuntime.JSArray",
-                        typeArguments: [elementTypeAst],
-                    },
+                    type: identifierType("global::Tsonic.JSRuntime.JSArray", [
+                        elementTypeAst,
+                    ]),
                     arguments: [captured.readExpression],
                 }),
                 createVarLocal(resultTemp.emittedName, mutationCall),
@@ -280,11 +282,7 @@ const emitArrayWrapperInteropCall = (expr, context) => {
     }
     const wrapperAst = {
         kind: "objectCreationExpression",
-        type: {
-            kind: "identifierType",
-            name: `global::${stripClrGenericArity(bindingType)}`,
-            typeArguments,
-        },
+        type: identifierType(`global::${stripClrGenericArity(bindingType)}`, typeArguments),
         arguments: [receiverAst],
     };
     const [argAsts, argContext] = emitCallArguments(expr.arguments, expr, currentContext);
@@ -314,20 +312,19 @@ const emitArrayWrapperInteropCall = (expr, context) => {
         currentContext,
     ];
 };
-const isTaskTypeAst = (typeAst) => {
-    if (typeAst.kind !== "identifierType")
-        return false;
-    const simple = typeAst.name.includes(".")
-        ? typeAst.name.slice(typeAst.name.lastIndexOf(".") + 1)
-        : typeAst.name;
-    return simple === "Task";
-};
+const isTaskTypeAst = (typeAst) => getIdentifierTypeLeafName(typeAst) === "Task";
 const containsVoidTypeAst = (typeAst) => {
     if (typeAst.kind === "predefinedType" && typeAst.keyword === "void") {
         return true;
     }
     if (typeAst.kind === "identifierType") {
-        if (typeAst.name === "void" || typeAst.name.endsWith(".void")) {
+        if (typeAst.name === "void") {
+            return true;
+        }
+        return (typeAst.typeArguments ?? []).some((t) => containsVoidTypeAst(t));
+    }
+    if (typeAst.kind === "qualifiedIdentifierType") {
+        if (getIdentifierTypeLeafName(typeAst) === "void") {
             return true;
         }
         return (typeAst.typeArguments ?? []).some((t) => containsVoidTypeAst(t));
@@ -346,9 +343,18 @@ const containsVoidTypeAst = (typeAst) => {
     }
     return false;
 };
-const getTaskResultType = (typeAst) => isTaskTypeAst(typeAst) && typeAst.typeArguments?.length === 1
-    ? typeAst.typeArguments[0]
-    : undefined;
+const getTaskResultType = (typeAst) => {
+    if (!isTaskTypeAst(typeAst)) {
+        return undefined;
+    }
+    if (typeAst.kind !== "identifierType" &&
+        typeAst.kind !== "qualifiedIdentifierType") {
+        return undefined;
+    }
+    return typeAst.typeArguments?.length === 1
+        ? typeAst.typeArguments[0]
+        : undefined;
+};
 const callbackParameterCount = (callbackExpr) => {
     if (callbackExpr.kind === "arrowFunction" ||
         callbackExpr.kind === "functionExpression") {
@@ -442,28 +448,15 @@ const buildDelegateType = (parameterTypes, returnType) => {
     const isVoidReturn = returnType?.kind === "predefinedType" && returnType.keyword === "void";
     if (returnType === undefined) {
         return parameterTypes.length === 0
-            ? { kind: "identifierType", name: "global::System.Action" }
-            : {
-                kind: "identifierType",
-                name: "global::System.Action",
-                typeArguments: parameterTypes,
-            };
+            ? identifierType("global::System.Action")
+            : identifierType("global::System.Action", parameterTypes);
     }
-    if (isVoidReturn ||
-        (returnType.kind === "identifierType" && returnType.name === "void")) {
+    if (isVoidReturn || getIdentifierTypeLeafName(returnType) === "void") {
         return parameterTypes.length === 0
-            ? { kind: "identifierType", name: "global::System.Action" }
-            : {
-                kind: "identifierType",
-                name: "global::System.Action",
-                typeArguments: parameterTypes,
-            };
+            ? identifierType("global::System.Action")
+            : identifierType("global::System.Action", parameterTypes);
     }
-    return {
-        kind: "identifierType",
-        name: "global::System.Func",
-        typeArguments: [...parameterTypes, returnType],
-    };
+    return identifierType("global::System.Func", [...parameterTypes, returnType]);
 };
 const isVoidOrUnknownIrType = (type) => type === undefined ||
     type.kind === "voidType" ||
@@ -571,8 +564,8 @@ const emitFunctionValueCallArguments = (args, signature, expr, context) => {
                 ? parameter.type.elementType
                 : undefined;
             let elementTypeAst = {
-                kind: "identifierType",
-                name: "object",
+                kind: "predefinedType",
+                keyword: "object",
             };
             if (restElementType) {
                 const [emittedType, typeCtx] = emitTypeAst(restElementType, currentContext);
@@ -729,8 +722,7 @@ const emitFlattenedRestArguments = (restArgs, restElementType, context) => {
                 {
                     kind: "invocationExpression",
                     expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Array.Empty",
+                        ...identifierExpression("global::System.Array.Empty"),
                     },
                     typeArguments: [elementTypeAst],
                     arguments: [],
@@ -739,15 +731,30 @@ const emitFlattenedRestArguments = (restArgs, restElementType, context) => {
             currentContext,
         ];
     }
-    let concatAst = segments[0];
+    const firstSegment = segments[0];
+    if (!firstSegment) {
+        return [
+            [
+                {
+                    kind: "arrayCreationExpression",
+                    elementType: elementTypeAst,
+                    initializer: [],
+                },
+            ],
+            currentContext,
+        ];
+    }
+    let concatAst = firstSegment;
     for (let index = 1; index < segments.length; index++) {
+        const segment = segments[index];
+        if (!segment)
+            continue;
         concatAst = {
             kind: "invocationExpression",
             expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Linq.Enumerable.Concat",
+                ...identifierExpression("global::System.Linq.Enumerable.Concat"),
             },
-            arguments: [concatAst, segments[index]],
+            arguments: [concatAst, segment],
         };
     }
     return [
@@ -755,8 +762,7 @@ const emitFlattenedRestArguments = (restArgs, restElementType, context) => {
             {
                 kind: "invocationExpression",
                 expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::System.Linq.Enumerable.ToArray",
+                    ...identifierExpression("global::System.Linq.Enumerable.ToArray"),
                 },
                 arguments: [concatAst],
             },
@@ -849,25 +855,15 @@ const mergePromiseChainResultIrTypes = (...types) => {
     };
 };
 const buildTaskTypeAst = (resultType) => resultType
-    ? {
-        kind: "identifierType",
-        name: "global::System.Threading.Tasks.Task",
-        typeArguments: [resultType],
-    }
-    : {
-        kind: "identifierType",
-        name: "global::System.Threading.Tasks.Task",
-    };
+    ? identifierType("global::System.Threading.Tasks.Task", [resultType])
+    : identifierType("global::System.Threading.Tasks.Task");
 const buildTaskRunInvocation = (outputTaskType, body, isAsync) => {
     const resultType = getTaskResultType(outputTaskType);
     return {
         kind: "invocationExpression",
         expression: {
             kind: "memberAccessExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Threading.Tasks.Task",
-            },
+            expression: identifierExpression("global::System.Threading.Tasks.Task"),
             memberName: "Run",
         },
         arguments: [
@@ -883,35 +879,22 @@ const buildTaskRunInvocation = (outputTaskType, body, isAsync) => {
 };
 const buildCompletedTaskAst = () => ({
     kind: "memberAccessExpression",
-    expression: {
-        kind: "identifierExpression",
-        identifier: "global::System.Threading.Tasks.Task",
-    },
+    expression: identifierExpression("global::System.Threading.Tasks.Task"),
     memberName: "CompletedTask",
 });
 const buildPromiseRejectedExceptionAst = (reasonAst) => {
-    const reasonExpr = reasonAst ??
-        {
-            kind: "literalExpression",
-            text: "null",
-        };
+    const reasonExpr = reasonAst ?? nullLiteral();
     return {
         kind: "binaryExpression",
         operatorToken: "??",
         left: {
             kind: "asExpression",
             expression: reasonExpr,
-            type: {
-                kind: "identifierType",
-                name: "global::System.Exception",
-            },
+            type: identifierType("global::System.Exception"),
         },
         right: {
             kind: "objectCreationExpression",
-            type: {
-                kind: "identifierType",
-                name: "global::System.Exception",
-            },
+            type: identifierType("global::System.Exception"),
             arguments: [
                 {
                     kind: "binaryExpression",
@@ -926,8 +909,7 @@ const buildPromiseRejectedExceptionAst = (reasonAst) => {
                         arguments: [],
                     },
                     right: {
-                        kind: "literalExpression",
-                        text: '"Promise rejected"',
+                        ...stringLiteral("Promise rejected"),
                     },
                 },
             ],
@@ -1063,10 +1045,7 @@ const emitPromiseNormalizedTaskAst = (valueAst, valueType, resultTypeAst, contex
             kind: "invocationExpression",
             expression: {
                 kind: "memberAccessExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::System.Threading.Tasks.Task",
-                },
+                expression: identifierExpression("global::System.Threading.Tasks.Task"),
                 memberName: "FromResult",
             },
             typeArguments: [resultTypeAst],
@@ -1108,10 +1087,7 @@ const emitPromiseStaticCall = (expr, context) => {
                 kind: "invocationExpression",
                 expression: {
                     kind: "memberAccessExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Threading.Tasks.Task",
-                    },
+                    expression: identifierExpression("global::System.Threading.Tasks.Task"),
                     memberName: "FromException",
                 },
                 typeArguments: outputResultType ? [outputResultType] : undefined,
@@ -1140,10 +1116,7 @@ const emitPromiseStaticCall = (expr, context) => {
         currentContext = normalizedTaskContext;
         normalizedValuesAst = {
             kind: "invocationExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Linq.Enumerable.Select",
-            },
+            expression: identifierExpression("global::System.Linq.Enumerable.Select"),
             arguments: [
                 valuesAst,
                 {
@@ -1166,10 +1139,7 @@ const emitPromiseStaticCall = (expr, context) => {
                 kind: "invocationExpression",
                 expression: {
                     kind: "memberAccessExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Threading.Tasks.Task",
-                    },
+                    expression: identifierExpression("global::System.Threading.Tasks.Task"),
                     memberName: "WhenAll",
                 },
                 arguments: [normalizedValuesAst],
@@ -1181,10 +1151,7 @@ const emitPromiseStaticCall = (expr, context) => {
         kind: "invocationExpression",
         expression: {
             kind: "memberAccessExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Threading.Tasks.Task",
-            },
+            expression: identifierExpression("global::System.Threading.Tasks.Task"),
             memberName: "WhenAny",
         },
         arguments: [normalizedValuesAst],
@@ -1262,18 +1229,14 @@ const buildDynamicImportContainerType = (targetModule) => {
     const containerName = targetModule.hasTypeCollision
         ? `${targetModule.className}__Module`
         : targetModule.className;
-    return {
-        kind: "identifierType",
-        name: `global::${targetModule.namespace}.${containerName}`,
-    };
+    return identifierType(`global::${targetModule.namespace}.${containerName}`);
 };
 const buildRunClassConstructorExpression = (containerType) => ({
     kind: "invocationExpression",
     expression: {
         kind: "memberAccessExpression",
         expression: {
-            kind: "identifierExpression",
-            identifier: "global::System.Runtime.CompilerServices.RuntimeHelpers",
+            ...identifierExpression("global::System.Runtime.CompilerServices.RuntimeHelpers"),
         },
         memberName: "RunClassConstructor",
     },
@@ -1297,10 +1260,7 @@ const emitDynamicImportCall = (expr, context) => {
         return null;
     const completedTaskExpr = {
         kind: "memberAccessExpression",
-        expression: {
-            kind: "identifierExpression",
-            identifier: "global::System.Threading.Tasks.Task",
-        },
+        expression: identifierExpression("global::System.Threading.Tasks.Task"),
         memberName: "CompletedTask",
     };
     const targetModule = resolveDynamicImportTargetModule(specifier, context);
@@ -1315,10 +1275,7 @@ const emitDynamicImportCall = (expr, context) => {
                 kind: "invocationExpression",
                 expression: {
                     kind: "memberAccessExpression",
-                    expression: {
-                        kind: "identifierExpression",
-                        identifier: "global::System.Threading.Tasks.Task",
-                    },
+                    expression: identifierExpression("global::System.Threading.Tasks.Task"),
                     memberName: "Run",
                 },
                 arguments: [
@@ -1347,7 +1304,7 @@ const emitDynamicImportCall = (expr, context) => {
         ? [
             {
                 kind: "objectCreationExpression",
-                type: { kind: "identifierType", name: "object" },
+                type: { kind: "predefinedType", keyword: "object" },
                 arguments: [],
             },
             currentContext,
@@ -1395,10 +1352,9 @@ const emitPromiseThenCatchFinally = (expr, context) => {
         : expr.inferredType;
     const [rawOutputTaskType, outputTaskCtx] = emitTypeAst(outputTypeHint ?? { kind: "referenceType", name: "Task" }, currentContext);
     currentContext = outputTaskCtx;
-    const defaultOutputTaskType = isTaskTypeAst(rawOutputTaskType) &&
-        rawOutputTaskType.typeArguments?.length === 1 &&
-        containsVoidTypeAst(rawOutputTaskType.typeArguments[0])
-        ? { kind: "identifierType", name: "global::System.Threading.Tasks.Task" }
+    const rawOutputTaskResultType = getTaskResultType(rawOutputTaskType);
+    const defaultOutputTaskType = rawOutputTaskResultType && containsVoidTypeAst(rawOutputTaskResultType)
+        ? identifierType("global::System.Threading.Tasks.Task")
         : rawOutputTaskType;
     const [sourceTaskType, sourceTaskCtx] = emitTypeAst(expr.callee.object.inferredType ?? { kind: "referenceType", name: "Task" }, currentContext);
     currentContext = sourceTaskCtx;
@@ -1471,7 +1427,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
         : {
             kind: "localDeclarationStatement",
             modifiers: [],
-            type: { kind: "identifierType", name: "var" },
+            type: { kind: "varType" },
             declarators: [
                 {
                     name: valueIdent,
@@ -1579,7 +1535,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
         const callbackCallee = rejectedAst.kind === "lambdaExpression"
             ? {
                 kind: "castExpression",
-                type: buildDelegateType([{ kind: "identifierType", name: "global::System.Exception" }], callbackReturnTypeAst),
+                type: buildDelegateType([identifierType("global::System.Exception")], callbackReturnTypeAst),
                 expression: rejectedAst,
             }
             : rejectedAst;
@@ -1644,10 +1600,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
                     body: { kind: "blockStatement", statements: thenStatements },
                     catches: [
                         {
-                            type: {
-                                kind: "identifierType",
-                                name: "global::System.Exception",
-                            },
+                            type: identifierType("global::System.Exception"),
                             identifier: exIdent,
                             body: {
                                 kind: "blockStatement",
@@ -1677,7 +1630,7 @@ const emitPromiseThenCatchFinally = (expr, context) => {
             ];
         const catches = [
             {
-                type: { kind: "identifierType", name: "global::System.Exception" },
+                type: identifierType("global::System.Exception"),
                 identifier: exIdent,
                 body: {
                     kind: "blockStatement",
@@ -1817,10 +1770,7 @@ const emitJsRuntimeJsonParseCall = (expr, context, typeArgument) => {
             kind: "invocationExpression",
             expression: {
                 kind: "memberAccessExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::Tsonic.JSRuntime.JSON",
-                },
+                expression: identifierExpression("global::Tsonic.JSRuntime.JSON"),
                 memberName: "parse",
             },
             arguments: argAsts,
@@ -1878,19 +1828,13 @@ const emitJsonSerializerCall = (expr, context, method, deserializeTypeOverride)
     // unknown and should emit plain JsonSerializer calls without requiring the
     // generated TsonicJson helper.
     if (context.options.jsonAotRegistry?.needsJsonAot) {
-        argAsts.push({
-            kind: "identifierExpression",
-            identifier: "TsonicJson.Options",
-        });
+        argAsts.push(identifierExpression("TsonicJson.Options"));
     }
     const invocation = {
         kind: "invocationExpression",
         expression: {
             kind: "memberAccessExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: "global::System.Text.Json.JsonSerializer",
-            },
+            expression: identifierExpression("global::System.Text.Json.JsonSerializer"),
             memberName: method,
         },
         arguments: argAsts,
@@ -2055,10 +1999,7 @@ export const emitCall = (expr, context) => {
         ];
         const invocation = {
             kind: "invocationExpression",
-            expression: {
-                kind: "identifierExpression",
-                identifier: finalCalleeName,
-            },
+            expression: identifierExpression(finalCalleeName),
             arguments: allArgAsts,
             typeArguments: typeArgAsts.length > 0 ? typeArgAsts : undefined,
         };
@@ -2066,10 +2007,7 @@ export const emitCall = (expr, context) => {
         const callAst = expr.inferredType?.kind === "arrayType"
             ? {
                 kind: "invocationExpression",
-                expression: {
-                    kind: "identifierExpression",
-                    identifier: "global::System.Linq.Enumerable.ToArray",
-                },
+                expression: identifierExpression("global::System.Linq.Enumerable.ToArray"),
                 arguments: [invocation],
             }
             : invocation;