fix(codegen): better union-arm selection for object-literal return (#518)

cs01 · web-flow · commit 3e8f803bcba8 · 2026-04-17T11:05:13.000-07:00
* fix(codegen): better union-arm selection for object-literal return — pick smallest superset by field set instead of count equality * fix(codegen): propagate declared interface type through function/method/constructor args so object literals in scrambled field order get correct struct layout (#519) Co-authored-by: cs01 <cs01@users.noreply.github.com> --------- Co-authored-by: cs01 <cs01@users.noreply.github.com>
diff --git a/src/codegen/expressions/calls.ts b/src/codegen/expressions/calls.ts
@@ -866,6 +866,7 @@ export class CallExpressionGenerator {
     const resolvedFuncName = this.ctx.resolveImportAlias(expr.name);
     let returnType = "double";
     let paramTypes: string[] = [];
+    const paramTsTypes: string[] = [];
 
     const funcResult = this.getFunctionFromAST(expr.name);
     const func = funcResult as FunctionNode;
@@ -903,6 +904,7 @@ export class CallExpressionGenerator {
             this.ctx.interfaceStructGenHasInterface(stripNullable(p)),
           ),
         );
+        paramTsTypes.push(stripNullable(p));
       }
       // Integer-specialized callee: every double param/return becomes i64.
       // The existing FFI coercion paths in this loop already handle paramType
@@ -935,6 +937,7 @@ export class CallExpressionGenerator {
                 false,
               ),
             );
+            paramTsTypes.push(stripNullable(pType));
           }
         } else if (funcNode.paramTypes) {
           for (let i = 0; i < funcNode.paramTypes.length; i++) {
@@ -943,6 +946,7 @@ export class CallExpressionGenerator {
             paramTypes.push(
               mapParamTypeToLLVM(t, paramName, this.ctx.isEnumType(stripNullable(t)), false),
             );
+            paramTsTypes.push(stripNullable(t));
           }
         }
         if (funcNode.intSpecialized) {
@@ -967,7 +971,21 @@ export class CallExpressionGenerator {
     for (let i = 0; i < loopLimit; i++) {
       if (i < expr.args.length) {
         const paramType = paramTypes[i] || "double";
+        const argExpr = expr.args[i] as { type: string };
+        let savedDeclaredIface: string | undefined = undefined;
+        let wrappedDeclaredIface = false;
+        if (argExpr.type === "object" && i < paramTsTypes.length) {
+          const tsParamType = paramTsTypes[i];
+          if (tsParamType && this.ctx.interfaceStructGenHasInterface(tsParamType)) {
+            savedDeclaredIface = this.ctx.getCurrentDeclaredInterfaceType();
+            this.ctx.setCurrentDeclaredInterfaceType(tsParamType);
+            wrappedDeclaredIface = true;
+          }
+        }
         const result = this.ctx.generateExpression(expr.args[i], params);
+        if (wrappedDeclaredIface) {
+          this.ctx.setCurrentDeclaredInterfaceType(savedDeclaredIface);
+        }
         const resultType = this.ctx.getVariableType(result);
         if (paramType === "double" && resultType === "i8*") {
           argsList.push(`double 0.0`);
diff --git a/src/codegen/llvm-generator.ts b/src/codegen/llvm-generator.ts
@@ -3744,21 +3744,57 @@ export class LLVMGenerator extends BaseGenerator implements IGeneratorContext {
                 }
               }
               if (returnTypeName === this.currentFunctionTsReturnType) {
-                const numObjFields = objLit.properties ? objLit.properties.length : 0;
+                const objKeys: string[] = [];
+                if (objLit.properties) {
+                  for (let k = 0; k < objLit.properties.length; k++) {
+                    objKeys.push(objLit.properties[k].key);
+                  }
+                }
                 let bestMatch: string | null = null;
+                let bestMatchSize = -1;
+                let exactMatch: string | null = null;
                 for (let i = 0; i < parts.length; i++) {
                   const part = parts[i].trim();
                   if (part === "null" || part === "undefined") continue;
                   if (!bestMatch) bestMatch = part;
                   if (this.interfaceStructGen) {
                     const ifaceInfo = this.interfaceStructGen.getInterfaceStruct(part);
-                    if (ifaceInfo && ifaceInfo.fields && ifaceInfo.fields.length === numObjFields) {
-                      bestMatch = part;
-                      break;
+                    if (ifaceInfo && ifaceInfo.fields) {
+                      const fieldNames: string[] = [];
+                      for (let f = 0; f < ifaceInfo.fields.length; f++) {
+                        const field = ifaceInfo.fields[f] as { name: string };
+                        fieldNames.push(field.name);
+                      }
+                      let isSuperset = true;
+                      for (let k = 0; k < objKeys.length; k++) {
+                        let found = false;
+                        for (let f = 0; f < fieldNames.length; f++) {
+                          if (fieldNames[f] === objKeys[k]) {
+                            found = true;
+                            break;
+                          }
+                        }
+                        if (!found) {
+                          isSuperset = false;
+                          break;
+                        }
+                      }
+                      if (isSuperset) {
+                        if (ifaceInfo.fields.length === objKeys.length) {
+                          exactMatch = part;
+                          break;
+                        }
+                        if (bestMatchSize === -1 || ifaceInfo.fields.length < bestMatchSize) {
+                          bestMatch = part;
+                          bestMatchSize = ifaceInfo.fields.length;
+                        }
+                      }
                     }
                   }
                 }
-                if (bestMatch) {
+                if (exactMatch) {
+                  returnTypeName = exactMatch;
+                } else if (bestMatch) {
                   returnTypeName = bestMatch;
                 }
               }
diff --git a/src/codegen/types/objects/class.ts b/src/codegen/types/objects/class.ts
@@ -1160,7 +1160,21 @@ export class ClassGenerator {
     for (let ai = 0; ai < ctorLoopLimit; ai++) {
       if (ai < args.length) {
         const arg = args[ai];
+        const argBase = arg as { type: string };
+        let savedDeclaredIface: string | undefined = undefined;
+        let wrappedDeclaredIface = false;
+        if (argBase.type === "object" && ai < paramTypes.length) {
+          const tsParamType = paramTypes[ai];
+          if (tsParamType && this.ctx.interfaceStructGenHasInterface(tsParamType)) {
+            savedDeclaredIface = this.ctx.getCurrentDeclaredInterfaceType();
+            this.ctx.setCurrentDeclaredInterfaceType(tsParamType);
+            wrappedDeclaredIface = true;
+          }
+        }
         const val = this.ctx.generateExpression(arg, params);
+        if (wrappedDeclaredIface) {
+          this.ctx.setCurrentDeclaredInterfaceType(savedDeclaredIface);
+        }
         const argType = ai < paramLLVMTypes.length ? paramLLVMTypes[ai] : "double";
         if (argType === "double") {
           argParts.push(argType + " " + this.ctx.ensureDouble(val));
@@ -1257,9 +1271,22 @@ export class ClassGenerator {
           methodName === "json" &&
           className === "Context" &&
           !this.ctx.isStringExpression(arg);
+        let savedDeclaredIfaceM: string | undefined = undefined;
+        let wrappedDeclaredIfaceM = false;
+        if (argTyped.type === "object" && ai < paramTypes.length && !autoSerialize) {
+          const tsParamTypeM = paramTypes[ai];
+          if (tsParamTypeM && this.ctx.interfaceStructGenHasInterface(tsParamTypeM)) {
+            savedDeclaredIfaceM = this.ctx.getCurrentDeclaredInterfaceType();
+            this.ctx.setCurrentDeclaredInterfaceType(tsParamTypeM);
+            wrappedDeclaredIfaceM = true;
+          }
+        }
         const val = autoSerialize
           ? this.ctx.jsonGen.generateStringifyExpr(arg, params)
           : this.ctx.generateExpression(arg, params);
+        if (wrappedDeclaredIfaceM) {
+          this.ctx.setCurrentDeclaredInterfaceType(savedDeclaredIfaceM);
+        }
         this.ctx.setExpectedCallbackParamType(null);
 
         let argType = "double";
diff --git a/tests/fixtures/interfaces/call-arg-literal-scrambled-order.ts b/tests/fixtures/interfaces/call-arg-literal-scrambled-order.ts
@@ -0,0 +1,17 @@
+interface Config {
+  name: string;
+  port: number;
+  host: string;
+}
+
+function boot(cfg: Config): void {
+  if (cfg.name === "n1" && cfg.host === "h1" && cfg.port === 99) {
+    console.log("TEST_PASSED");
+  }
+}
+
+function main(): void {
+  boot({ host: "h1", port: 99, name: "n1" });
+}
+
+main();
diff --git a/tests/fixtures/interfaces/class-arg-literal-scrambled-order.ts b/tests/fixtures/interfaces/class-arg-literal-scrambled-order.ts
@@ -0,0 +1,26 @@
+interface Point {
+  x: number;
+  y: number;
+}
+
+class Vec {
+  dx: number;
+  dy: number;
+  constructor(p: Point) {
+    this.dx = p.x;
+    this.dy = p.y;
+  }
+  dot(other: Point): number {
+    return this.dx * other.x + this.dy * other.y;
+  }
+}
+
+function main(): void {
+  const v = new Vec({ y: 3, x: 4 });
+  const r = v.dot({ y: 10, x: 5 });
+  if (v.dx === 4 && v.dy === 3 && r === 4 * 5 + 3 * 10) {
+    console.log("TEST_PASSED");
+  }
+}
+
+main();
diff --git a/tests/fixtures/interfaces/union-return-subset-fields.ts b/tests/fixtures/interfaces/union-return-subset-fields.ts
@@ -0,0 +1,26 @@
+interface Big {
+  a: number;
+  b: number;
+  c: number;
+}
+
+interface Small {
+  a: number;
+}
+
+function pick(flag: boolean): Big | Small {
+  if (flag) {
+    return { a: 1, b: 2, c: 3 };
+  }
+  return { a: 7 };
+}
+
+function main(): void {
+  const big = pick(true) as Big;
+  const small = pick(false) as Small;
+  if (big.a === 1 && big.b === 2 && big.c === 3 && small.a === 7) {
+    console.log("TEST_PASSED");
+  }
+}
+
+main();
