@tsonic/emitter 0.0.63 → 0.0.64

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",
@@ -1269,6 +1545,192 @@ 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",