feat: Add TNew handling and generic type support in reflaxe

darmie · darmie · commit e34e621236e7 · 2025-11-27T14:33:39.000Z
- Add TNew expression handling to compile object instantiation
  (e.g., new StringMap&lt;Int&gt;() -&gt; $StringMap$new())
- Call addTypeForCompilation() to request class compilation when TNew is encountered
- Add Generic and Pointer type variants to AST.ZType for proper type representation
- Transform instance method calls with proper function types
  (e.g., map.set(k,v) -&gt; $StringMap$set(map, k, v))
- Add buildInstanceMethodType() and buildConstructorType() helpers
- Handle Null&lt;T&gt; abstract type by unwrapping to inner type
- Update Generator.hx and HirBuilder.hx to handle new type variants
- Add MapTest.hx demonstrating StringMap&lt;Int&gt; and IntMap&lt;String&gt; usage
diff --git a/reflaxe.zyntax/src/zyntax/AST.hx b/reflaxe.zyntax/src/zyntax/AST.hx
@@ -48,6 +48,8 @@ typedef Param = {
 enum ZType {
     Primitive(name: String);
     Function(params: Array<ZType>, returnType: ZType);
+    Generic(name: String, typeParams: Array<ZType>);  // e.g., StringMap<Int>, Array<String>
+    Pointer(inner: ZType);  // Pointer to a type (for class instances)
 }
 
 /**
diff --git a/reflaxe.zyntax/src/zyntax/Generator.hx b/reflaxe.zyntax/src/zyntax/Generator.hx
@@ -133,6 +133,15 @@ function generateType(t: AST.ZType): Dynamic {
                 nullability: "NonNull"
             }
         };
+        case Generic(name, typeParams): {
+            Generic: {
+                name: name,
+                type_params: typeParams.map(p -> generateType(p))
+            }
+        };
+        case Pointer(inner): {
+            Pointer: generateType(inner)
+        };
     }
 }
 
diff --git a/reflaxe.zyntax/src/zyntax/HirBuilder.hx b/reflaxe.zyntax/src/zyntax/HirBuilder.hx
@@ -381,6 +381,12 @@ class HirBuilder {
                 // For function types, we'd need a proper representation
                 // For now, just use a pointer
                 HirType.Ptr(HirType.I8);
+            case zyntax.AST.ZType.Generic(name, typeParams):
+                // Generic types like StringMap<Int> - treat as opaque pointer
+                HirType.Ptr(HirType.I8);
+            case zyntax.AST.ZType.Pointer(inner):
+                // Pointer to a type
+                HirType.Ptr(convertType(inner));
             case zyntax.AST.ZType.Primitive(_):
                 trace("Unknown primitive type: " + ty);
                 HirType.Void;
diff --git a/reflaxe.zyntax/src/zyntax/ZyntaxCompiler.hx b/reflaxe.zyntax/src/zyntax/ZyntaxCompiler.hx
@@ -153,36 +153,55 @@ class ZyntaxCompiler extends GenericCompiler<AST.Module, AST.Enum, AST.Expr> {
                 // Check if this is a method call on a standard library type
                 switch(callee.expr) {
                     case TField(obj, fa):
-                        // Get the method name
-                        var methodName = switch(fa) {
-                            case FInstance(_, _, cf): cf.get().name;
-                            case FAnon(cf): cf.get().name;
-                            case FClosure(_, cf): cf.get().name;
-                            default: null;
-                        };
-
-                        // Get the object type
-                        var objType = switch(obj.t) {
-                            case TInst(t, _): t.get().name;
-                            default: null;
-                        };
-
-                        // Transform stdlib method calls: arr.push(x) -> $Array$push(arr, x)
-                        if (methodName != null && objType != null) {
-                            var stdlibFunc = "$" + objType + "$" + methodName; // e.g., "$Array$push"
-                            var stdlibCallee: AST.ExprWithPos = {
-                                expr: AST.Expr.Variable(stdlibFunc),
-                                ty: convertType(expr.t),
-                                pos: callee.pos
-                            };
-                            var objExpr = wrapExpr(obj);
-                            var argExprs = args.map(a -> wrapExpr(a));
-                            AST.Expr.Call(stdlibCallee, [objExpr].concat(argExprs));
-                        } else {
-                            // Not a stdlib method call, use regular call
-                            var calleeExpr = wrapExpr(callee);
-                            var argExprs = args.map(a -> wrapExpr(a));
-                            AST.Expr.Call(calleeExpr, argExprs);
+                        // Handle static method calls (like Math.sqrt)
+                        switch(fa) {
+                            case FStatic(classRef, cf):
+                                // Static method call: Math.sqrt(x) -> $Math$sqrt(x)
+                                var className = classRef.get().name;
+                                var methodName = cf.get().name;
+                                var stdlibFunc = "$" + className + "$" + methodName;
+                                // Use the callee's type (function type) not the call result type
+                                var stdlibCallee: AST.ExprWithPos = {
+                                    expr: AST.Expr.Variable(stdlibFunc),
+                                    ty: convertType(callee.t),
+                                    pos: callee.pos
+                                };
+                                var argExprs = args.map(a -> wrapExpr(a));
+                                AST.Expr.Call(stdlibCallee, argExprs);
+
+                            case FInstance(_, _, cf) | FAnon(cf) | FClosure(_, cf):
+                                // Instance method call: arr.push(x) -> $Array$push(arr, x)
+                                var methodName = cf.get().name;
+                                var objType = switch(obj.t) {
+                                    case TInst(t, _): t.get().name;
+                                    default: null;
+                                };
+
+                                if (methodName != null && objType != null) {
+                                    var stdlibFunc = "$" + objType + "$" + methodName;
+                                    // Build function type: (self, original_args...) -> return_type
+                                    // We need to prepend the object type to the function params
+                                    var funcType = buildInstanceMethodType(obj.t, callee.t);
+                                    var stdlibCallee: AST.ExprWithPos = {
+                                        expr: AST.Expr.Variable(stdlibFunc),
+                                        ty: funcType,
+                                        pos: callee.pos
+                                    };
+                                    var objExpr = wrapExpr(obj);
+                                    var argExprs = args.map(a -> wrapExpr(a));
+                                    AST.Expr.Call(stdlibCallee, [objExpr].concat(argExprs));
+                                } else {
+                                    // Fallback to regular call
+                                    var calleeExpr = wrapExpr(callee);
+                                    var argExprs = args.map(a -> wrapExpr(a));
+                                    AST.Expr.Call(calleeExpr, argExprs);
+                                }
+
+                            default:
+                                // Other field types - regular call
+                                var calleeExpr = wrapExpr(callee);
+                                var argExprs = args.map(a -> wrapExpr(a));
+                                AST.Expr.Call(calleeExpr, argExprs);
                         }
 
                     default:
@@ -250,6 +269,27 @@ class ZyntaxCompiler extends GenericCompiler<AST.Module, AST.Enum, AST.Expr> {
                 // Parentheses are just for grouping, compile the inner expression
                 compileExpressionImpl(e, topLevel);
 
+            case TNew(clsRef, params, args):
+                // Object instantiation: new StringMap<Int>() -> $StringMap$new()
+                var cls = clsRef.get();
+                var className = cls.name;
+
+                // Request the class to be compiled (adds to dynamicTypeStack)
+                addTypeForCompilation(TInst(clsRef, params));
+
+                // Generate constructor call: $ClassName$new(args...)
+                var constructorFunc = "$" + className + "$new";
+                // Build function type: (arg_types...) -> instance_type
+                var argTypes = args.map(a -> a.t);
+                var constructorType = buildConstructorType(expr.t, argTypes);
+                var constructorCallee: AST.ExprWithPos = {
+                    expr: AST.Expr.Variable(constructorFunc),
+                    ty: constructorType,
+                    pos: expr.pos
+                };
+                var argExprs = args.map(a -> wrapExpr(a));
+                AST.Expr.Call(constructorCallee, argExprs);
+
             default:
                 // Debug: Print unsupported expression type
                 #if macro
@@ -300,11 +340,21 @@ class ZyntaxCompiler extends GenericCompiler<AST.Module, AST.Enum, AST.Expr> {
         return switch(t) {
             case TInst(_.get() => c, params):
                 switch(c.name) {
+                    // Primitive types
                     case "Int": Primitive("I32");
                     case "Float": Primitive("F64");
                     case "Bool": Primitive("Bool");
                     case "String": Primitive("String");
-                    default: Primitive("I32");
+                    // Generic class types - convert with type parameters
+                    default:
+                        if (params.length > 0) {
+                            // Generic type like StringMap<Int>, Array<String>
+                            var typeParams = params.map(p -> convertType(p));
+                            Generic(c.name, typeParams);
+                        } else {
+                            // Non-generic class - treat as pointer to class instance
+                            Pointer(Primitive(c.name));
+                        }
                 }
 
             case TAbstract(_.get() => a, params):
@@ -313,7 +363,21 @@ class ZyntaxCompiler extends GenericCompiler<AST.Module, AST.Enum, AST.Expr> {
                     case "Float": Primitive("F64");
                     case "Bool": Primitive("Bool");
                     case "Void": Primitive("Unit");
-                    default: Primitive("I32");
+                    case "Null":
+                        // Null<T> - the inner type is nullable
+                        if (params.length > 0) {
+                            // For now, just use the inner type (nullable handling TBD)
+                            convertType(params[0]);
+                        } else {
+                            Primitive("I32");
+                        }
+                    default:
+                        if (params.length > 0) {
+                            var typeParams = params.map(p -> convertType(p));
+                            Generic(a.name, typeParams);
+                        } else {
+                            Primitive("I32");
+                        }
                 }
 
             case TType(_.get() => dt, params):
@@ -356,6 +420,35 @@ class ZyntaxCompiler extends GenericCompiler<AST.Module, AST.Enum, AST.Expr> {
             default: "Add";
         }
     }
+
+    /**
+     * Build a function type for an instance method call.
+     * Transforms (args...) -> ret into (self, args...) -> ret
+     * where self is the object type.
+     */
+    function buildInstanceMethodType(objType: Type, methodType: Type): AST.ZType {
+        switch(methodType) {
+            case TFun(args, ret):
+                // Prepend the object type as first parameter (self)
+                var selfType = convertType(objType);
+                var paramTypes = [selfType].concat(args.map(arg -> convertType(arg.t)));
+                var returnType = convertType(ret);
+                return Function(paramTypes, returnType);
+            default:
+                // Fallback: just return the method type
+                return convertType(methodType);
+        }
+    }
+
+    /**
+     * Build a function type for a constructor call.
+     * Returns (args...) -> InstanceType
+     */
+    function buildConstructorType(instanceType: Type, argTypes: Array<Type>): AST.ZType {
+        var paramTypes = argTypes.map(t -> convertType(t));
+        var returnType = convertType(instanceType);
+        return Function(paramTypes, returnType);
+    }
 }
 
 #end
diff --git a/reflaxe.zyntax/test/MapTest.hx b/reflaxe.zyntax/test/MapTest.hx
@@ -0,0 +1,34 @@
+import haxe.ds.StringMap;
+import haxe.ds.IntMap;
+
+class MapTest {
+    public static function main():Void {
+        // Test StringMap
+        var strMap = new StringMap<Int>();
+        strMap.set("one", 1);
+        strMap.set("two", 2);
+        strMap.set("three", 3);
+
+        var val1 = strMap.get("one");
+        var val2 = strMap.get("two");
+
+        // Test IntMap
+        var intMap = new IntMap<String>();
+        intMap.set(1, "one");
+        intMap.set(2, "two");
+
+        var str1 = intMap.get(1);
+        var str2 = intMap.get(2);
+
+        // Test exists
+        var hasOne = strMap.exists("one");
+        var hasFour = strMap.exists("four");
+
+        trace("StringMap test:");
+        trace("  get('one') = " + val1);
+        trace("  get('two') = " + val2);
+        trace("IntMap test:");
+        trace("  get(1) = " + str1);
+        trace("  get(2) = " + str2);
+    }
+}
diff --git a/reflaxe.zyntax/test/build_map.hxml b/reflaxe.zyntax/test/build_map.hxml
@@ -0,0 +1,4 @@
+-lib reflaxe.zyntax
+-main MapTest
+-D zyntax-output=output
+--macro exclude('haxe.Log')

Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,8 @@ typedef Param = {`
`48`	`48`	`enum ZType {`
`49`	`49`	`Primitive(name: String);`
`50`	`50`	`Function(params: Array<ZType>, returnType: ZType);`
	`51`	`+ Generic(name: String, typeParams: Array<ZType>); // e.g., StringMap<Int>, Array<String>`
	`52`	`+ Pointer(inner: ZType); // Pointer to a type (for class instances)`
`51`	`53`	`}`
`52`	`54`
`53`	`55`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,15 @@ function generateType(t: AST.ZType): Dynamic {`
`133`	`133`	`nullability: "NonNull"`
`134`	`134`	`}`
`135`	`135`	`};`
	`136`	`+ case Generic(name, typeParams): {`
	`137`	`+ Generic: {`
	`138`	`+ name: name,`
	`139`	`+ type_params: typeParams.map(p -> generateType(p))`
	`140`	`+ }`
	`141`	`+ };`
	`142`	`+ case Pointer(inner): {`
	`143`	`+ Pointer: generateType(inner)`
	`144`	`+ };`
`136`	`145`	`}`
`137`	`146`	`}`
`138`	`147`