return some proper types if possible

std/python/Syntax.hx

@@ -15,7 +15,7 @@ class Syntax {
     #end
 
 	@:noUsing macro public static function importModule (module:String):haxe.macro.Expr {
-		return macro $self.untypedPython($v{"import " + module});
+		return macro ($self.untypedPython($v{"import " + module}):Void);
 	}
 
 	@:noUsing macro public static function importAs (module:String, className : String):haxe.macro.Expr
@@ -24,30 +24,30 @@ class Syntax {
         var e = "import " + module + " as " + n;
         var e1 = "_hx_c."+n+" = "+n;
 
-	    return macro{
+	    return macro ({
             $self.untypedPython($v{e});
             $self.untypedPython($v{e1});
-        }
+        }:Void);
     }
 
     @:noUsing macro public static function isIn <T>(a:Expr, b:Expr):haxe.macro.Expr
     {
-        return macro (untyped __python_in__)($a, $b);
+        return macro ((untyped __python_in__)($a, $b):Bool);
     }
 
     @:noUsing macro public static function delete <T>(a:Expr):haxe.macro.Expr
     {
-        return macro (untyped __python_del__)($a);
+        return macro ((untyped __python_del__)($a):Void);
     }
 
     @:noUsing macro public static function binop <T>(a:Expr, op:String, b:Expr):haxe.macro.Expr
     {
-        return macro ((untyped __python_binop__)($a, $v{op}, $b));
+        return macro (((untyped __python_binop__)($a, $v{op}, $b)):Dynamic);
     }
 
     @:noUsing macro public static function assign <T>(a:Expr, b:Expr):haxe.macro.Expr
     {
-        return macro (untyped __python_assign__)($a, $b);
+        return macro ((untyped __python_assign__)($a, $b):Void);
     }
 
 
@@ -60,12 +60,12 @@ class Syntax {
 
     @:noUsing macro public static function arrayAccess <T>(x:Expr, rest:Array<Expr>):haxe.macro.ExprOf<Dynamic>
     {
-        return macro (untyped __python_array_get__)($a{[x].concat(rest)});
+        return macro ((untyped __python_array_get__)($a{[x].concat(rest)}):Dynamic);
     }
 
     @:noUsing macro public static function arrayAccessWithLeadingColon <T>(x:Expr, rest:Array<Expr>):haxe.macro.ExprOf<Dynamic>
     {
-        return macro (untyped __python_array_access_leading_colon__)($a{[x].concat(rest)});
+        return macro ((untyped __python_array_access_leading_colon__)($a{[x].concat(rest)}):Dynamic);
     }
 
     @:noUsing macro public static function pyFor <T>(v:Expr, it:Expr, b:Expr):haxe.macro.Expr
@@ -82,7 +82,7 @@ class Syntax {
             $it;
             $b;
         }
-        return macro (untyped __python_for__)($res);
+        return macro ((untyped __python_for__)($res):Void);
     }
 
     @:noUsing macro public static function importFromAs (from:String, module:String, className : String):haxe.macro.Expr {
@@ -91,10 +91,10 @@ class Syntax {
 
         var e = "from " + from + " import " + module + " as " + n;
         var e1 = "_hx_c."+n+" = " + n;
-	    return macro {
+	    return macro ({
             $self.untypedPython($v{e});
             $self.untypedPython($v{e1});
-        }
+        }:Void);
     }
 
     @:noUsing macro public static function callField (o:Expr, field:ExprOf<String>, params:Array<Expr>):haxe.macro.Expr {
@@ -109,7 +109,7 @@ class Syntax {
     #if !macro macro #end
     public static function field (o:Expr, field:ExprOf<String>):haxe.macro.Expr
     {
-        return macro (untyped __field__)($o, $field);
+        return macro ((untyped __field__)($o, $field):Dynamic);
     }
 
     @:noUsing
@@ -136,12 +136,12 @@ class Syntax {
                 // TODO check at least if fields are valid (maybe if types match);
             case _ : haxe.macro.Context.error("args must be an ObjectDeclaration like { name : 1 }", args.pos);
         }
-        return macro @:pos(e.pos) (untyped __named__)($e, $args);
+        return macro @:pos(e.pos) ((untyped __named__)($e, $args):Dynamic);
     }
 
     macro public static function callNamedUntyped (e:Expr, args:Expr):haxe.macro.Expr
     {
-        return macro @:pos(e.pos) (untyped __named__)($e, $args);
+        return macro @:pos(e.pos) ((untyped __named__)($e, $args):Dynamic);
     }