@tsonic/emitter 0.0.62 → 0.0.64

package/dist/expressions/index.js

@@ -4,7 +4,7 @@
 // Literals
 export { emitLiteral } from "./literals.js";
 // Identifiers and type helpers
-export { emitIdentifier, emitTypeArguments, generateSpecializedName, } from "./identifiers.js";
+export { emitIdentifier, generateSpecializedName } from "./identifiers.js";
 // Collections
 export { emitArray, emitObject } from "./collections.js";
 // Member access

package/dist/expressions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/expressions/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,WAAW;AACX,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,+BAA+B;AAC/B,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAE1B,cAAc;AACd,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEzD,gBAAgB;AAChB,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,QAAQ;AACR,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE/C,YAAY;AACZ,OAAO,EACL,UAAU,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,cAAc,EACd,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAExB,YAAY;AACZ,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE3E,QAAQ;AACR,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/expressions/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,WAAW;AACX,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,+BAA+B;AAC/B,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3E,cAAc;AACd,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEzD,gBAAgB;AAChB,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,QAAQ;AACR,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE/C,YAAY;AACZ,OAAO,EACL,UAAU,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,cAAc,EACd,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAExB,YAAY;AACZ,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE3E,QAAQ;AACR,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/dist/expressions/index.test.js

@@ -349,6 +349,126 @@ describe("Expression Emission", () => {
         expect(result).to.include('global::Tsonic.JSRuntime.String.split(path, "/")');
         expect(result).not.to.include("path.split");
     });
+    it("should rewrite js-surface array functional calls via LINQ", () => {
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "call",
+                        callee: {
+                            kind: "memberAccess",
+                            object: {
+                                kind: "identifier",
+                                name: "nums",
+                                inferredType: {
+                                    kind: "arrayType",
+                                    elementType: { kind: "primitiveType", name: "int" },
+                                },
+                            },
+                            property: "map",
+                            isComputed: false,
+                            isOptional: false,
+                        },
+                        arguments: [{ kind: "identifier", name: "doubleIt" }],
+                        isOptional: false,
+                        inferredType: {
+                            kind: "arrayType",
+                            elementType: { kind: "primitiveType", name: "int" },
+                        },
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module, { surface: "js" });
+        expect(result).to.include("global::System.Linq.Enumerable.Select(nums, doubleIt)");
+        expect(result).to.include("global::System.Linq.Enumerable.ToArray(");
+        expect(result).not.to.include("new global::Tsonic.JSRuntime.JSArray");
+    });
+    it("should rewrite js-surface reduce/reduceRight/join via deterministic CLR calls", () => {
+        const numsExpr = {
+            kind: "identifier",
+            name: "nums",
+            inferredType: {
+                kind: "arrayType",
+                elementType: { kind: "primitiveType", name: "int" },
+            },
+        };
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "call",
+                        callee: {
+                            kind: "memberAccess",
+                            object: numsExpr,
+                            property: "reduce",
+                            isComputed: false,
+                            isOptional: false,
+                        },
+                        arguments: [
+                            { kind: "identifier", name: "sum" },
+                            { kind: "literal", value: 0 },
+                        ],
+                        isOptional: false,
+                    },
+                },
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "call",
+                        callee: {
+                            kind: "memberAccess",
+                            object: numsExpr,
+                            property: "reduceRight",
+                            isComputed: false,
+                            isOptional: false,
+                        },
+                        arguments: [
+                            { kind: "identifier", name: "sum" },
+                            { kind: "literal", value: 0 },
+                        ],
+                        isOptional: false,
+                    },
+                },
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "call",
+                        callee: {
+                            kind: "memberAccess",
+                            object: numsExpr,
+                            property: "join",
+                            isComputed: false,
+                            isOptional: false,
+                        },
+                        arguments: [],
+                        isOptional: false,
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module, { surface: "js" });
+        expect(result).to.include("global::System.Linq.Enumerable.Aggregate(nums, 0, sum)");
+        expect(result).to.include("global::System.Linq.Enumerable.Aggregate(global::System.Linq.Enumerable.Reverse(nums), 0, sum)");
+        expect(result).to.include('global::System.String.Join(",", nums)');
+        expect(result).not.to.include("new global::Tsonic.JSRuntime.JSArray");
+    });
     it("should emit fluent LINQ extension method calls (required for EF query precompilation)", () => {
         const module = {
             kind: "module",
@@ -965,6 +1085,162 @@ describe("Expression Emission", () => {
         // Should emit regular property access
         expect(result).to.include("obj.property");
     });
+    it("should emit array Length for js/node surfaces when binding provides lowercase length", () => {
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "memberAccess",
+                        object: {
+                            kind: "identifier",
+                            name: "nums",
+                            inferredType: {
+                                kind: "arrayType",
+                                elementType: { kind: "primitiveType", name: "int" },
+                            },
+                        },
+                        property: "length",
+                        isComputed: false,
+                        isOptional: false,
+                        memberBinding: {
+                            assembly: "Tsonic.JSRuntime",
+                            type: "Tsonic.JSRuntime.JSArray",
+                            member: "length",
+                        },
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const jsResult = emitModule(module, { surface: "js" });
+        expect(jsResult).to.include("nums.Length");
+        expect(jsResult).not.to.include("nums.length");
+        const nodeResult = emitModule(module, { surface: "nodejs" });
+        expect(nodeResult).to.include("nums.Length");
+        expect(nodeResult).not.to.include("nums.length");
+    });
+    it("should emit array Length for js/node surfaces without member binding", () => {
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "memberAccess",
+                        object: {
+                            kind: "identifier",
+                            name: "nums",
+                            inferredType: {
+                                kind: "arrayType",
+                                elementType: { kind: "primitiveType", name: "int" },
+                            },
+                        },
+                        property: "length",
+                        isComputed: false,
+                        isOptional: false,
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const jsResult = emitModule(module, { surface: "js" });
+        expect(jsResult).to.include("nums.Length");
+        expect(jsResult).not.to.include("nums.length");
+        const nodeResult = emitModule(module, { surface: "nodejs" });
+        expect(nodeResult).to.include("nums.Length");
+        expect(nodeResult).not.to.include("nums.length");
+    });
+    it("should emit array Length for js/node surfaces when array type is referenceType", () => {
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "memberAccess",
+                        object: {
+                            kind: "identifier",
+                            name: "nums",
+                            inferredType: {
+                                kind: "referenceType",
+                                name: "Array",
+                                typeArguments: [{ kind: "primitiveType", name: "int" }],
+                            },
+                        },
+                        property: "length",
+                        isComputed: false,
+                        isOptional: false,
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const jsResult = emitModule(module, { surface: "js" });
+        expect(jsResult).to.include("nums.Length");
+        expect(jsResult).not.to.include("nums.length");
+        const nodeResult = emitModule(module, { surface: "nodejs" });
+        expect(nodeResult).to.include("nums.Length");
+        expect(nodeResult).not.to.include("nums.length");
+    });
+    it("should emit array Length for js/node surfaces with member binding and ReadonlyArray referenceType", () => {
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "memberAccess",
+                        object: {
+                            kind: "identifier",
+                            name: "nums",
+                            inferredType: {
+                                kind: "referenceType",
+                                name: "ReadonlyArray",
+                                typeArguments: [{ kind: "primitiveType", name: "int" }],
+                            },
+                        },
+                        property: "length",
+                        isComputed: false,
+                        isOptional: false,
+                        memberBinding: {
+                            assembly: "Tsonic.JSRuntime",
+                            type: "Tsonic.JSRuntime.JSArray",
+                            member: "length",
+                        },
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const jsResult = emitModule(module, { surface: "js" });
+        expect(jsResult).to.include("nums.Length");
+        expect(jsResult).not.to.include("nums.length");
+        const nodeResult = emitModule(module, { surface: "nodejs" });
+        expect(nodeResult).to.include("nums.Length");
+        expect(nodeResult).not.to.include("nums.length");
+    });
     it("should project CLR Union_n member access deterministically", () => {
         const unionReference = {
             kind: "referenceType",
@@ -1165,6 +1441,64 @@ describe("Expression Emission", () => {
         // Should be a Dictionary with global:: prefix
         expect(result).to.include("new global::System.Collections.Generic.Dictionary<string, double>");
     });
+    it("should emit computed string-literal keys for nominal object initializers", () => {
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "interfaceDeclaration",
+                    name: "Box",
+                    typeParameters: [],
+                    extends: [],
+                    members: [
+                        {
+                            kind: "propertySignature",
+                            name: "foo",
+                            type: { kind: "primitiveType", name: "number" },
+                            isOptional: false,
+                            isReadonly: false,
+                        },
+                    ],
+                    isExported: false,
+                    isStruct: false,
+                },
+                {
+                    kind: "variableDeclaration",
+                    declarationKind: "const",
+                    isExported: false,
+                    declarations: [
+                        {
+                            kind: "variableDeclarator",
+                            name: { kind: "identifierPattern", name: "box" },
+                            type: { kind: "referenceType", name: "Box" },
+                            initializer: {
+                                kind: "object",
+                                properties: [
+                                    {
+                                        kind: "property",
+                                        key: { kind: "literal", value: "foo" },
+                                        value: { kind: "literal", value: 1 },
+                                        shorthand: false,
+                                    },
+                                ],
+                                contextualType: { kind: "referenceType", name: "Box" },
+                                inferredType: { kind: "referenceType", name: "Box" },
+                            },
+                        },
+                    ],
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module);
+        expect(result).not.to.include("/* computed */");
+        expect(result).to.include("foo = 1");
+    });
     it("should lower dictionary[key] !== undefined to ContainsKey", () => {
         const dictType = {
             kind: "dictionaryType",
@@ -1211,6 +1545,277 @@ describe("Expression Emission", () => {
         expect(result).to.include('(dict).ContainsKey("x")');
         expect(result).to.not.include('dict["x"] != null');
     });
+    it("should lower dictionary.Keys to a materialized key array", () => {
+        const dictType = {
+            kind: "dictionaryType",
+            keyType: { kind: "primitiveType", name: "string" },
+            valueType: { kind: "primitiveType", name: "number" },
+        };
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "variableDeclaration",
+                    declarationKind: "const",
+                    isExported: false,
+                    declarations: [
+                        {
+                            kind: "variableDeclarator",
+                            name: { kind: "identifierPattern", name: "keys" },
+                            initializer: {
+                                kind: "memberAccess",
+                                object: {
+                                    kind: "identifier",
+                                    name: "dict",
+                                    inferredType: dictType,
+                                },
+                                property: "Keys",
+                                isComputed: false,
+                                isOptional: false,
+                                inferredType: {
+                                    kind: "arrayType",
+                                    elementType: { kind: "primitiveType", name: "string" },
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module);
+        expect(result).to.include("new global::System.Collections.Generic.List<string>(dict.Keys).ToArray()");
+    });
+    it("should lower dictionary.Values to a materialized value array", () => {
+        const dictType = {
+            kind: "dictionaryType",
+            keyType: { kind: "primitiveType", name: "string" },
+            valueType: { kind: "referenceType", name: "long" },
+        };
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "variableDeclaration",
+                    declarationKind: "const",
+                    isExported: false,
+                    declarations: [
+                        {
+                            kind: "variableDeclarator",
+                            name: { kind: "identifierPattern", name: "values" },
+                            initializer: {
+                                kind: "memberAccess",
+                                object: {
+                                    kind: "identifier",
+                                    name: "dict",
+                                    inferredType: dictType,
+                                },
+                                property: "Values",
+                                isComputed: false,
+                                isOptional: false,
+                                inferredType: {
+                                    kind: "arrayType",
+                                    elementType: { kind: "referenceType", name: "long" },
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module);
+        expect(result).to.include("new global::System.Collections.Generic.List<long>(dict.Values).ToArray()");
+    });
+    it("should upcast dictionary values into union wrappers for expected dictionary union types", () => {
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "variableDeclaration",
+                    declarationKind: "const",
+                    isExported: false,
+                    declarations: [
+                        {
+                            kind: "variableDeclarator",
+                            name: { kind: "identifierPattern", name: "widened" },
+                            type: {
+                                kind: "dictionaryType",
+                                keyType: { kind: "primitiveType", name: "string" },
+                                valueType: {
+                                    kind: "unionType",
+                                    types: [
+                                        { kind: "referenceType", name: "int" },
+                                        { kind: "primitiveType", name: "string" },
+                                    ],
+                                },
+                            },
+                            initializer: {
+                                kind: "identifier",
+                                name: "raw",
+                                inferredType: {
+                                    kind: "dictionaryType",
+                                    keyType: { kind: "primitiveType", name: "string" },
+                                    valueType: { kind: "referenceType", name: "int" },
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module);
+        expect(result).to.include("global::System.Linq.Enumerable.ToDictionary");
+        expect(result).to.include("global::Tsonic.Runtime.Union<int, string>.From1");
+    });
+    it("should not upcast when dictionary value type already matches union runtime type", () => {
+        const unionType = {
+            kind: "unionType",
+            types: [
+                { kind: "referenceType", name: "int" },
+                { kind: "primitiveType", name: "string" },
+            ],
+        };
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "variableDeclaration",
+                    declarationKind: "const",
+                    isExported: false,
+                    declarations: [
+                        {
+                            kind: "variableDeclarator",
+                            name: { kind: "identifierPattern", name: "alreadyWide" },
+                            type: {
+                                kind: "dictionaryType",
+                                keyType: { kind: "primitiveType", name: "string" },
+                                valueType: unionType,
+                            },
+                            initializer: {
+                                kind: "identifier",
+                                name: "input",
+                                inferredType: {
+                                    kind: "dictionaryType",
+                                    keyType: { kind: "primitiveType", name: "string" },
+                                    valueType: unionType,
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module);
+        expect(result).not.to.include("global::System.Linq.Enumerable.ToDictionary");
+    });
+    it("should lower symbol-key dictionary undefined checks to ContainsKey", () => {
+        const dictType = {
+            kind: "dictionaryType",
+            keyType: { kind: "referenceType", name: "object" },
+            valueType: { kind: "primitiveType", name: "number" },
+        };
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "ifStatement",
+                    condition: {
+                        kind: "binary",
+                        operator: "===",
+                        left: {
+                            kind: "memberAccess",
+                            object: {
+                                kind: "identifier",
+                                name: "dict",
+                                inferredType: dictType,
+                            },
+                            property: { kind: "identifier", name: "key" },
+                            isComputed: true,
+                            isOptional: false,
+                            accessKind: "dictionary",
+                            inferredType: { kind: "primitiveType", name: "number" },
+                        },
+                        right: { kind: "identifier", name: "undefined" },
+                    },
+                    thenStatement: {
+                        kind: "blockStatement",
+                        statements: [],
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module);
+        expect(result).to.include("!(dict).ContainsKey(key)");
+        expect(result).to.not.include("dict[key] == null");
+    });
+    it("should lower delete on symbol-key dictionary access to Remove", () => {
+        const dictType = {
+            kind: "dictionaryType",
+            keyType: { kind: "referenceType", name: "object" },
+            valueType: { kind: "primitiveType", name: "number" },
+        };
+        const module = {
+            kind: "module",
+            filePath: "/src/test.ts",
+            namespace: "MyApp",
+            className: "test",
+            isStaticContainer: true,
+            imports: [],
+            body: [
+                {
+                    kind: "expressionStatement",
+                    expression: {
+                        kind: "unary",
+                        operator: "delete",
+                        expression: {
+                            kind: "memberAccess",
+                            object: {
+                                kind: "identifier",
+                                name: "dict",
+                                inferredType: dictType,
+                            },
+                            property: { kind: "identifier", name: "key" },
+                            isComputed: true,
+                            isOptional: false,
+                            accessKind: "dictionary",
+                        },
+                    },
+                },
+            ],
+            exports: [],
+        };
+        const result = emitModule(module);
+        expect(result).to.include("dict.Remove(key);");
+    });
     it("should infer arrow function return type from inferredType", () => {
         const module = {
             kind: "module",