rename python.Macros to python.Syntax

std/python/Boot.hx

@@ -9,7 +9,7 @@ import python.internal.HxOverrides;
 import python.internal.HxException;
 import python.internal.AnonObject;
 
-import python.Macros;
+import python.Syntax;
 
 
 private extern class Set <T>
@@ -40,13 +40,13 @@ import math as _hx_math
 @:keep class Boot {
 
 	@:keep static function __init__ () {
-		Macros.importAs("inspect", "_hx_boot_inspect");
-		Boot.inspect = Macros.untypedPython("_hx_boot_inspect");
+		Syntax.importAs("inspect", "_hx_boot_inspect");
+		Boot.inspect = Syntax.untypedPython("_hx_boot_inspect");
 
-		Boot.builtin = Macros.untypedPython("_hx_builtin");
+		Boot.builtin = Syntax.untypedPython("_hx_builtin");
 	}
 
-	static function mkSet <T>(a:Array<T>):Set<T> return Macros.callField(builtin, "set", a);
+	static function mkSet <T>(a:Array<T>):Set<T> return Syntax.callField(builtin, "set", a);
 
 	static var keywords:Set<String> = mkSet(
     [
@@ -61,58 +61,58 @@ import math as _hx_math
     ]);
 
 	static function arrayJoin <T>(x:Array<T>, sep:String):String {
-		return Macros.field(sep, "join")(x.map(python.Boot.toString));
+		return Syntax.field(sep, "join")(x.map(python.Boot.toString));
 	}
 
 
 	static function isInstance(o:Dynamic, x:Dynamic):Bool {
-		return Macros.callField(builtin, "isinstance", o, x);
+		return Syntax.callField(builtin, "isinstance", o, x);
 	}
 
 	static function builtinStr(o:Dynamic):String {
-		return Macros.callField(builtin, "str", o);
+		return Syntax.callField(builtin, "str", o);
 	}
 
 	static function builtinHasAttr(o:Dynamic, x:String):Bool {
-		return Macros.callField(builtin, "hasattr", o, x);
+		return Syntax.callField(builtin, "hasattr", o, x);
 	}
 
 	static function builtinGetAttr(o:Dynamic, x:String):Dynamic {
-		return Macros.callField(builtin, "getattr", o, x);
+		return Syntax.callField(builtin, "getattr", o, x);
 	}
 
 	static function isPyBool(o:Dynamic):Bool {
-		return isInstance(o, Macros.field(builtin, "bool"));
+		return isInstance(o, Syntax.field(builtin, "bool"));
 	}
 	static function isPyInt(o:Dynamic):Bool {
-		return isInstance(o, Macros.field(builtin, "int"));
+		return isInstance(o, Syntax.field(builtin, "int"));
 	}
 	static function isPyFloat(o:Dynamic):Bool {
-		return isInstance(o, Macros.field(builtin, "float"));
+		return isInstance(o, Syntax.field(builtin, "float"));
 	}
 
 
 	static function builtinLen(o:Dynamic):Int {
-		return Macros.callField(builtin, "len", o);
+		return Syntax.callField(builtin, "len", o);
 	}
 	static function builtinInt(o:Dynamic):Int {
-		return Macros.callField(builtin, "int", o);
+		return Syntax.callField(builtin, "int", o);
 	}
 	static function builtinCallable(o:Dynamic):Bool {
-		return Macros.callField(builtin, "callable", o);
+		return Syntax.callField(builtin, "callable", o);
 	}
 	static function inspectGetMembers(o:Dynamic, f:String->Bool):Void {
-		return Macros.callField(inspect, "getmembers", o, f);
+		return Syntax.callField(inspect, "getmembers", o, f);
 	}
 
 	static function inspectIsClass(o:Dynamic):Bool {
-		return Macros.callField(inspect, "isclass", o);
+		return Syntax.callField(inspect, "isclass", o);
 	}
 	static function inspectIsFunction(o:Dynamic):Bool {
-		return Macros.callField(inspect, "isclass", o);
+		return Syntax.callField(inspect, "isclass", o);
 	}
 	static function inspectIsMethod(o:Dynamic):Bool {
-		return Macros.callField(inspect, "isclass", o);
+		return Syntax.callField(inspect, "isclass", o);
 	}
 
 
@@ -137,7 +137,7 @@ import math as _hx_math
 		if (isInstance(a, String) || isInstance(b, String)) {
 			return toString1(a,"") + toString1(b,"");
 		}
-		return Macros.pyBinop(a, "+", b);
+		return Syntax.pyBinop(a, "+", b);
     }
 
     @:keep static function toString (o:Dynamic) {
@@ -250,7 +250,7 @@ import math as _hx_math
 			}
 
 
-			if (builtinHasAttr(o, "_hx_class_name") && Macros.field(Macros.field(o, "__class__"), "__name__") != "type") {
+			if (builtinHasAttr(o, "_hx_class_name") && Syntax.field(Syntax.field(o, "__class__"), "__name__") != "type") {
 
 				var fields = getInstanceFields(o);
 				var fieldsStr = [for (f in fields) '$f : ${toString1(field(o,f), s+"\t")}'];
@@ -259,7 +259,7 @@ import math as _hx_math
 				return toStr;
 			}
 
-			if (builtinHasAttr(o, "_hx_class_name") && Macros.field(Macros.field(o, "__class__"), "__name__") == "type") {
+			if (builtinHasAttr(o, "_hx_class_name") && Syntax.field(Syntax.field(o, "__class__"), "__name__") == "type") {
 
 				var fields = getClassFields(o);
 				var fieldsStr = [for (f in fields) '$f : ${toString1(field(o,f), s+"\t")}'];
@@ -283,16 +283,16 @@ import math as _hx_math
 			}
 			try {
 				if (builtinHasAttr(o, "__repr__")) {
-					return Macros.callField(o, "__repr__");
+					return Syntax.callField(o, "__repr__");
 				}
 			} catch (e:Dynamic) {}
 
 			if (builtinHasAttr(o, "__str__")) {
-				return Macros.callField(o, "__str__", []);
+				return Syntax.callField(o, "__str__", []);
 			}
 
 			if (builtinHasAttr(o, "__name__")) {
-				return Macros.field(o, "__name__");
+				return Syntax.field(o, "__name__");
 			}
 			return "???";
 		} else {
@@ -311,26 +311,26 @@ import math as _hx_math
 		{
 			if (builtinHasAttr(o, "_hx_fields"))
 			{
-				var fields:Array<String> = Macros.field(o, "_hx_fields");
+				var fields:Array<String> = Syntax.field(o, "_hx_fields");
 				return fields.copy();
 			}
 			if (isInstance(o, AnonObject))
 			{
 
-				var d:Dynamic = Macros.field(o, "__dict__");
+				var d:Dynamic = Syntax.field(o, "__dict__");
 				var keys  = d.keys();
 				var handler = unhandleKeywords;
 
-				Macros.untypedPython("for k in keys:");
-				Macros.untypedPython("	a.append(handler(k))");
+				Syntax.untypedPython("for k in keys:");
+				Syntax.untypedPython("	a.append(handler(k))");
 			}
 			else if (builtinHasAttr(o, "__dict__"))
 			{
 				var a = [];
-				var d:Dynamic = Macros.field(o, "__dict__");
+				var d:Dynamic = Syntax.field(o, "__dict__");
 				var keys  = d.keys();
-				Macros.untypedPython("for k in keys:");
-				Macros.untypedPython("	a.append(k)");
+				Syntax.untypedPython("for k in keys:");
+				Syntax.untypedPython("	a.append(k)");
 
 			}
 		}
@@ -390,8 +390,8 @@ import math as _hx_math
 
 	static function getInstanceFields( c : Class<Dynamic> ) : Array<String> {
 		var f = if (builtinHasAttr(c, "_hx_fields")) {
-			var x:Array<String> = Macros.field(c, "_hx_fields");
-			var x2:Array<String> = Macros.field(c, "_hx_methods");
+			var x:Array<String> = Syntax.field(c, "_hx_fields");
+			var x2:Array<String> = Syntax.field(c, "_hx_methods");
 			x.concat(x2);
 		} else {
 			[];
@@ -421,9 +421,9 @@ import math as _hx_math
 
 		try {
 			if (builtinHasAttr(c, "_hx_super")) {
-				return Macros.field(c, "_hx_super");
+				return Syntax.field(c, "_hx_super");
 			}
-			return Macros.arrayAccess(Macros.field("c", "__bases__"), 0);
+			return Syntax.arrayAccess(Syntax.field("c", "__bases__"), 0);
 		} catch (e:Dynamic) {
 
 		}
@@ -433,7 +433,7 @@ import math as _hx_math
 
 	static function getClassFields( c : Class<Dynamic> ) : Array<String> {
 		if (builtinHasAttr(c, "_hx_statics")) {
-			var x:Array<String> = Macros.field(c, "_hx_statics");
+			var x:Array<String> = Syntax.field(c, "_hx_statics");
 			return x.copy();
 		} else {
 			return [];

std/python/Macros.hx

@@ -10,9 +10,9 @@ import haxe.macro.ExprTools;
 
 
 
-class Macros {
+class Syntax {
     #if macro
-    static var self = macro python.Macros;
+    static var self = macro python.Syntax;
     #end
 
 	@:noUsing macro public static function importModule (module:String):haxe.macro.Expr {
@@ -89,7 +89,7 @@ class Macros {
 
     @:noUsing macro public static function callField (o:Expr, field:ExprOf<String>, params:Array<Expr>):haxe.macro.Expr {
 
-        var field = python.Macros.field(o, field);
+        var field = python.Syntax.field(o, field);
         var params = [field].concat(params);
 
         return macro untyped __call__($a{params});

std/python/Syntax.hx

@@ -0,0 +1,131 @@
+package python;
+
+#if macro
+import haxe.macro.Expr;
+
+import haxe.macro.Context;
+
+import haxe.macro.ExprTools;
+#end
+
+
+
+class Syntax {
+    #if macro
+    static var self = macro python.Syntax;
+    #end
+
+	@:noUsing macro public static function importModule (module:String):haxe.macro.Expr {
+		return macro $self.untypedPython($v{"import " + module});
+	}
+
+	@:noUsing macro public static function importAs (module:String, className : String):haxe.macro.Expr
+    {
+
+        var n = className.split(".").join("_");
+
+        var e = "import " + module + " as " + n;
+        var e1 = "_hx_c."+n+" = "+n;
+
+
+
+	    return macro{
+            $self.untypedPython($v{e});
+            $self.untypedPython($v{e1});
+        }
+    }
+
+    @:noUsing macro public static function isIn <T>(a:Expr, b:Expr):haxe.macro.Expr
+    {
+        return macro untyped __python_in__($a, $b);
+    }
+
+    @:noUsing macro public static function pyBinop <T>(a:Expr, op:String, b:Expr):haxe.macro.Expr
+    {
+        return macro untyped __python_binop__($a, $v{op}, $b);
+    }
+
+
+    @:noUsing
+    #if (!macro) macro #end
+    public static function untypedPython <T>(b:String):haxe.macro.ExprOf<Dynamic>
+    {
+        return macro untyped __python__($v{b});
+    }
+
+    @: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)});
+    }
+
+    @:noUsing macro public static function pyFor <T>(v:Expr, it:Expr, b:Expr):haxe.macro.Expr
+    {
+        var id = switch (v.expr) {
+            case EConst(CIdent(x)):x;
+            case _ : Context.error("unexpected " + ExprTools.toString(v) + ": const ident expected", v.pos);
+        }
+
+
+
+        var res = macro @:pos(it.pos) {
+            var $id = $it.getNativeIterator().__next__();
+            $it;
+            $b;
+        }
+        return macro (untyped __python_for__)($res);
+    }
+
+    @:noUsing macro public static function importFromAs (from:String, module:String, className : String):haxe.macro.Expr {
+
+        var n = className.split(".").join("_");
+
+        var e = "from " + from + " import " + module + " as " + n;
+        var e1 = "_hx_c."+n+" = " + n;
+	    return macro {
+            $self.untypedPython($v{e});
+            $self.untypedPython($v{e1});
+        }
+    }
+
+    @:noUsing macro public static function callField (o:Expr, field:ExprOf<String>, params:Array<Expr>):haxe.macro.Expr {
+
+        var field = python.Syntax.field(o, field);
+        var params = [field].concat(params);
+
+        return macro untyped __call__($a{params});
+    }
+
+    @:noUsing
+    #if !macro macro #end
+    public static function field (o:Expr, field:ExprOf<String>):haxe.macro.Expr
+    {
+        return macro untyped __field__($o, $field);
+    }
+
+    @:noUsing
+    #if !macro macro #end
+    public static function callNamed (e:Expr, args:Expr):haxe.macro.Expr {
+        var fArgs = switch (Context.typeof(e)) {
+            case TFun(args, ret): args;
+            case _ : haxe.macro.Context.error("e must be of type function", e.pos);
+        }
+        switch (args.expr) {
+            case EObjectDecl(fields):
+                for (f in fields) {
+                    var found = false;
+                    for (a in fArgs) {
+                        found = a.name == f.field;
+                        if (found) break;
+                    }
+                    if (!found) {
+                        haxe.macro.Context.error("field " + f.field + " is not a valid argument (valid names " + [for (a in fArgs) a.name].join(",") + ")", args.pos);
+                    }
+                }
+                // 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);
+    }
+
+
+}

std/python/_std/Math.hx

@@ -299,7 +299,7 @@ extern class Math
 	}
 
 	static function __init__():Void untyped {
-		python.Macros.importAs("math", "_hx_math");
+		python.Syntax.importAs("math", "_hx_math");
 		NEGATIVE_INFINITY = __python__("float")('-inf');
 		POSITIVE_INFINITY = __python__("float")('inf');
 		NaN = __python__("float")('nan');

std/python/_std/String.hx

@@ -200,7 +200,7 @@ extern class String {
 	}
 
 	@:keep static function __init__ ():Void {
-		python.Macros.importFromAs("builtins", "str", "String");
+		python.Syntax.importFromAs("builtins", "str", "String");
 	}
 
 

std/python/internal/ArrayImpl.hx

@@ -33,14 +33,14 @@ class ArrayImpl {
 
 	static inline function builtin():Builtin return untyped __python__("_hx_builtin");
 
-	public static inline function get_length <T>(x:Array<T>):Int return Macros.field(builtin(), "len")(x);
+	public static inline function get_length <T>(x:Array<T>):Int return Syntax.field(builtin(), "len")(x);
 
 	public static inline function concat<T>( a1:Array<T>, a2 : Array<T>) : Array<T> {
 		return untyped (untyped a1) + (untyped a2);
 	}
 
 	public static inline function copy<T>(x:Array<T>) : Array<T> {
-		return Macros.field(builtin(), "list")(x);
+		return Syntax.field(builtin(), "list")(x);
 	}
 
 	@:keep public static inline function iterator<T>(x:Array<T>) : Iterator<T> {
@@ -73,7 +73,7 @@ class ArrayImpl {
 
 	@:access(python.Boot)
 	public static inline function join<T>(x:Array<T>, sep : String ) : String {
-		return Macros.field(sep, "join")(x.map(python.Boot.toString));
+		return Syntax.field(sep, "join")(x.map(python.Boot.toString));
 	}
 
 	public static inline function toString<T>(x:Array<T>) : String {
@@ -85,7 +85,7 @@ class ArrayImpl {
 	}
 
 	public static inline function push<T>(x:Array<T>, e:T) : Int {
-		Macros.callField(x, "append", e);
+		Syntax.callField(x, "append", e);
 		return get_length(x);
 	}
 
@@ -95,7 +95,7 @@ class ArrayImpl {
 
 	@:keep public static function remove<T>(x:Array<T>,e : T) : Bool {
 		try {
-			Macros.callField(x, "remove", e);
+			Syntax.callField(x, "remove", e);
 			return true;
 		} catch (e:Dynamic) {
 			return false;
@@ -124,19 +124,19 @@ class ArrayImpl {
 	}
 
 	@:keep public static inline function map<S,T>(x:Array<T>, f : T -> S ) : Array<S> {
-		return Macros.field(builtin(), "list")(Macros.field(builtin(), "map")(f,cast x));
+		return Syntax.field(builtin(), "list")(Syntax.field(builtin(), "map")(f,cast x));
 	}
 
 	@:keep public static inline function filter<T>(x:Array<T>, f : T -> Bool ) : Array<T> {
-		return Macros.field(builtin(), "list")(Macros.field(builtin(), "filter")(f, x));
+		return Syntax.field(builtin(), "list")(Syntax.field(builtin(), "filter")(f, x));
 	}
 
 	public static inline function insert<T>(a:Array<T>, pos : Int, x : T ) : Void {
-		return Macros.callField(a, "insert", pos, x);
+		return Syntax.callField(a, "insert", pos, x);
 
 	}
 	public static inline function reverse<T>(a:Array<T>) : Void {
-		return Macros.callField(a, "reverse");
+		return Syntax.callField(a, "reverse");
 	}
 
 	@:keep private static inline function __get<T>(x:Array<T>, idx:Int):T {

std/python/internal/StringImpl.hx

@@ -11,7 +11,7 @@ class StringImpl {
 
 
 	public static function split (s:String, d:String) {
-		return if (d == "") Macros.field(builtin(), "list")(s) else Macros.callField(s, "split", d);
+		return if (d == "") Syntax.field(builtin(), "list")(s) else Syntax.callField(s, "split", d);
 	}
 
 	public static function charCodeAt(s:String, index:Int) {
@@ -26,7 +26,7 @@ class StringImpl {
 		} else {
 
 			var i = (untyped s.rfind)(str, 0, startIndex+1);
-			var startLeft = i == -1 ? Macros.field(builtin(), "max")(0,startIndex+1-str.length) : i+1;
+			var startLeft = i == -1 ? Syntax.field(builtin(), "max")(0,startIndex+1-str.length) : i+1;
 			var check = (untyped s.find)(str, startLeft, s.length);
 			if (check > i && check <= startIndex) {
 				return check;
@@ -37,17 +37,17 @@ class StringImpl {
 	}
 
 	public static function toUpperCase (s:String) {
-		return Macros.callField(s, "upper");
+		return Syntax.callField(s, "upper");
 	}
 
 	public static function toLowerCase (s:String) {
-		return Macros.callField(s, "lower");
+		return Syntax.callField(s, "lower");
 	}
 	public static function indexOf (s:String, str:String, ?startIndex:Int) {
 		if (startIndex == null)
-			return Macros.callField(s, "find", str);
+			return Syntax.callField(s, "find", str);
 		else
-			return Macros.callField(s, "find", str, startIndex);
+			return Syntax.callField(s, "find", str, startIndex);
 	}
 
 	public static function toString (s:String) {
@@ -55,7 +55,7 @@ class StringImpl {
 	}
 
 	public static function get_length (s:String) {
-		return Macros.field(builtin(), "len")(s);
+		return Syntax.field(builtin(), "len")(s);
 	}
 
 	public static inline function fromCharCode( code : Int ) : String {
@@ -63,7 +63,7 @@ class StringImpl {
 		return "";
 		#else
 		var c = code;
-		return (Macros.field('', "join")(Macros.field(builtin(), "map")(Macros.field(builtin(), "chr"), cast [c])):String); // TODO: check cast
+		return (Syntax.field('', "join")(Syntax.field(builtin(), "map")(Syntax.field(builtin(), "chr"), cast [c])):String); // TODO: check cast
 		#end
 	}
 

std/python/lib/Codecs.hx

@@ -35,7 +35,7 @@ extern class StreamReaderWriterText implements StreamReader implements StreamWri
 
 	public function write(object:Dynamic):Void;
 	public function writelines(list:Array<String>):Void;
-	
+
 	public function close():Void;
 
 	public function encode(input:Dynamic, ?errors:String = "strict"):Tup2<String, Int>;
@@ -48,6 +48,6 @@ extern class Codecs {
 	public static function open(filename:String, mode:String, ?encoding:String, ?errors:String, ?buffering:Bool):StreamReaderWriterText;
 
 	static function __init__ ():Void {
-		Macros.importAs("codecs", "python.lib.Codecs");
+		Syntax.importAs("codecs", "python.lib.Codecs");
 	}
 }

std/python/lib/Glob.hx

@@ -8,11 +8,11 @@ extern class Glob {
 	public static function glob (pathname:String):Array<String>;
 	public static function iglob (pathname:String):PyIterator<String>;
 
-	
 
-	static function __init__ ():Void 
+
+	static function __init__ ():Void
 	{
-		Macros.importAs("glob", "python.lib.Glob");
+		Syntax.importAs("glob", "python.lib.Glob");
 	}
 
 }

std/python/lib/Inspect.hx

@@ -1,13 +1,13 @@
 
 package python.lib;
 
-import python.Macros;
+import python.Syntax;
 
 extern class Inspect {
 
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		python.Macros.importAs("inspect", "python.lib.Inspect");
+		python.Syntax.importAs("inspect", "python.lib.Inspect");
 	}
 
 	static function getmembers (value:Dynamic, ?filter:Dynamic->Bool):Bool;
@@ -16,5 +16,5 @@ extern class Inspect {
 
 	static function isfunction(value:Dynamic):Bool;
 
-	
+
 }

std/python/lib/Json.hx

@@ -5,11 +5,11 @@ import python.lib.Types.Dict;
 
 extern class Json {
 
-	
+
 	public static function loads (s:String):Dict<String, Dynamic>;
 
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		python.Macros.importAs("json", "python.lib.Json");
+		python.Syntax.importAs("json", "python.lib.Json");
 	}
 }

std/python/lib/Msvcrt.hx

@@ -8,7 +8,7 @@ extern class Msvcrt {
 	static function __init__ ():Void
 	{
 		try {
-			python.Macros.importAs("msvcrt", "python.lib.Msvcrt");
+			python.Syntax.importAs("msvcrt", "python.lib.Msvcrt");
 		} catch (e:Dynamic) {}
 	}
 

std/python/lib/Os.hx

@@ -70,7 +70,7 @@ extern class Os {
 
 	static function __init__ ():Void
 	{
-		python.Macros.importAs("os", "python.lib.Os");
+		python.Syntax.importAs("os", "python.lib.Os");
 	}
 
 }

std/python/lib/PPrint.hx

@@ -3,13 +3,13 @@ package python.lib;
 
 extern class PPrint {
 
-	
+
 	public static function pprint (x:Dynamic):Void;
 
 	public static function pformat(object:Dynamic, indent:Int=1, width:Int=80, depth:Int=null):String;
 
 	static function __init__ ():Void {
-		python.Macros.importAs("pprint", "python.lib.PPrint");
+		python.Syntax.importAs("pprint", "python.lib.PPrint");
 	}
 
 }

std/python/lib/Random.hx

@@ -8,7 +8,7 @@ extern class Random {
 	public static function random ():Float;
 
 	static function __init__ ():Void {
-		Macros.importAs("random", "python.lib.Random");
+		Syntax.importAs("random", "python.lib.Random");
 	}
 
 }

std/python/lib/Re.hx

@@ -14,10 +14,10 @@ typedef Repl = Choice<String, MatchObject->String>;
 
 
 
-extern class MatchObject 
+extern class MatchObject
 {
-	
-	public var pos(default, null):Int;	
+
+	public var pos(default, null):Int;
 	public var endpos(default, null):Int;
 	public var lastindex(default, null):Int;
 	public var lastgroup(default, null):Int;
@@ -40,11 +40,11 @@ extern class MatchObject
 	}
 
 	public inline function startById(s:String):Int {
-		return start(untyped s);	
+		return start(untyped s);
 	}
 
 	public inline function endById(s:String):Int {
-		return end(untyped s);	
+		return end(untyped s);
 	}
 
 }
@@ -61,15 +61,15 @@ private class RegexHelper {
 		} else {
 			return untyped __field__(r, "findall")(string, pos, endpos);
 		}
-		
-	}	
+
+	}
 }
 
-extern class Regex 
+extern class Regex
 {
 	public function search(string:String, pos:Int = 0, ?endpos:Int):Null<MatchObject>;
 	public function match(string:String, pos:Int = 0, ?endpos:Int):Null<MatchObject>;
-	
+
 	public function split(string:String, maxsplit:Int=0):Array<String>;
 
 	public inline function findallString(string:String, ?pos:Int, ?endpos:Int):Array<String>
@@ -94,10 +94,10 @@ extern class Regex
 	}
 
 	public function finditer(string:String, ?pos:Int, ?endpos:Int):PyIterator<MatchObject>;
-	
+
 	public function sub(repl:Repl, string:String, count:Int=0):String;
 	public function subn(repl:Repl, string:String, count:Int=0):String;
-	
+
 	public var flags(default, null):Int;
 	public var groups(default, null):Int;
 	public var groupindex(default, null):Dict<String, Int>;
@@ -106,7 +106,7 @@ extern class Regex
 
 
 
-extern class Re 
+extern class Re
 {
 
 	public static var A:Int;
@@ -130,13 +130,13 @@ extern class Re
 	public static var U:Int;
 	public static var UNICODE:Int;
 
-	
-	
+
+
 	public static function compile (pattern:String, ?flags:Int = 0):Regex;
 
 	public static function match (pattern:Pattern, string:String, flags:Int = 0):Null<MatchObject>;
 
-	public static function search (pattern:Pattern, string:String, flags:Int = 0):Null<MatchObject>;	
+	public static function search (pattern:Pattern, string:String, flags:Int = 0):Null<MatchObject>;
 
 	public static function split(pattern:Pattern, string:String, 	   maxsplit:Int=0, flags:Int=0):Array<String>;
 
@@ -144,7 +144,7 @@ extern class Re
 	{
 		return untyped __field__(pattern, "findall")(string, flags);
 	}
-	
+
 
 	public static inline function findallString(pattern:Pattern, string:String,    flags:Int=0):Array<String>
 	{
@@ -163,7 +163,7 @@ extern class Re
 
 	public static function finditer(pattern:Pattern, string:String,   flags:Int=0):PyIterator<MatchObject>;
 
-	
+
 	@:overload(function (pattern:Pattern, repl:String, string:String,  ?count:Int=0, ?flags:Int=0):String {})
 	public static function sub(pattern:Pattern, repl:MatchObject->String, string:String,  ?count:Int=0, ?flags:Int=0):String;
 
@@ -174,6 +174,6 @@ extern class Re
 	public static function purge():Void;
 
 	static function __init__ ():Void {
-		python.Macros.importAs("re", "python.lib.Re");
+		python.Syntax.importAs("re", "python.lib.Re");
 	}
 }

std/python/lib/ShUtil.hx

@@ -14,6 +14,6 @@ extern class ShUtil {
 	public static function copy2 (src:String, dst:String):Void;
 
 	static function __init__ ():Void {
-		Macros.importAs("shutil", "python.lib.ShUtil");
+		Syntax.importAs("shutil", "python.lib.ShUtil");
 	}
 }

std/python/lib/Subprocess.hx

@@ -31,6 +31,6 @@ extern class Subprocess {
 
 	static function __init__ ():Void
 	{
-		python.Macros.importAs("subprocess", "python.lib.Subprocess");
+		python.Syntax.importAs("subprocess", "python.lib.Subprocess");
 	}
 }

std/python/lib/Sys.hx

@@ -26,7 +26,7 @@ extern class Sys {
 
 	static function __init__ ():Void
 	{
-		python.Macros.importAs("sys", "python.lib.Sys");
+		python.Syntax.importAs("sys", "python.lib.Sys");
 	}
 
 }

std/python/lib/Tempfile.hx

@@ -5,7 +5,7 @@ extern class Tempfile {
 
 	public static function gettempdir():String;
 	static function __init__ ():Void {
-		Macros.importAs("tempfile", "python.lib.Tempfile");
+		Syntax.importAs("tempfile", "python.lib.Tempfile");
 	}
 
 }

std/python/lib/Termios.hx

@@ -15,7 +15,7 @@ extern class Termios {
 	static function __init__ ():Void
 	{
 		try {
-			python.Macros.importAs("termios", "python.lib.Termios");
+			python.Syntax.importAs("termios", "python.lib.Termios");
 		}
 		catch (e:Dynamic) {}
 	}

std/python/lib/ThreadLowLevel.hx

@@ -6,12 +6,12 @@ import python.lib.Types.Tuple;
 private typedef TODO = Dynamic;
 
 extern class ThreadLowLevel {
-	
+
 	public static function start_new_thread(f:Void->Void, args:Tuple<Dynamic>):TODO;
 
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		python.Macros.importAs("_thread", "python.lib.ThreadLowLevel");
+		python.Syntax.importAs("_thread", "python.lib.ThreadLowLevel");
 	}
 
 }

std/python/lib/Time.hx

@@ -8,6 +8,6 @@ extern class Time {
 	public static function sleep (t:Float):Void;
 	static function __init__ ():Void
 	{
-		python.Macros.importAs("time", "python.lib.Time");
+		python.Syntax.importAs("time", "python.lib.Time");
 	}
 }

std/python/lib/Tty.hx

@@ -8,7 +8,7 @@ extern class Tty {
 	static function __init__ ():Void
 	{
 		try {
-			python.Macros.importAs("tty", "python.lib.Tty");
+			python.Syntax.importAs("tty", "python.lib.Tty");
 		} catch (e:Dynamic) {}
 
 	}

std/python/lib/Types.hx

@@ -44,7 +44,7 @@ extern class Bytes extends ByteArray {
 
 	static function __init__ ():Void
 	{
-		Macros.importFromAs("builtins", "bytes", "python.lib.Bytes");
+		Syntax.importFromAs("builtins", "bytes", "python.lib.Bytes");
 	}
 
 
@@ -148,7 +148,7 @@ extern class Set <T>
 
 	static function __init__ ():Void
 	{
-		Macros.importFromAs("builtins", "set", "python.lib.Set");
+		Syntax.importFromAs("builtins", "set", "python.lib.Set");
 	}
 
 	function __iter__ ():PyIterator<T>;
@@ -219,7 +219,7 @@ extern class Dict <K, V>
 
 	static function __init__ ():Void
 	{
-		Macros.importFromAs("builtins", "dict", "python.lib.Dict");
+		Syntax.importFromAs("builtins", "dict", "python.lib.Dict");
 	}
 
 }

std/python/lib/datetime/DateTime.hx

@@ -40,6 +40,6 @@ extern class DateTime {
 
 	static function __init__ ():Void
 	{
-		python.Macros.importFromAs("datetime", "datetime", "python.lib.datetime.DateTime");
+		python.Syntax.importFromAs("datetime", "datetime", "python.lib.datetime.DateTime");
 	}
 }

std/python/lib/datetime/TimeDelta.hx

@@ -17,6 +17,6 @@ extern class TimeDelta {
 
 	static function __init__ ():Void
 	{
-		python.Macros.importFromAs("datetime", "timedelta", "python.lib.datetime.TimeDelta");
+		python.Syntax.importFromAs("datetime", "timedelta", "python.lib.datetime.TimeDelta");
 	}
 }

std/python/lib/datetime/Timezone.hx

@@ -4,8 +4,8 @@ package python.lib.datetime;
 extern class Timezone extends TzInfo {
 
 	public static var utc(default, never):TzInfo;
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		python.Macros.importFromAs("datetime", "timezone", "python.lib.datetime.Timezone");
+		python.Syntax.importFromAs("datetime", "timezone", "python.lib.datetime.Timezone");
 	}
 }

std/python/lib/datetime/TzInfo.hx

@@ -3,9 +3,9 @@ package python.lib.datetime;
 
 extern class TzInfo {
 
-	
-	static function __init__ ():Void 
+
+	static function __init__ ():Void
 	{
-		python.Macros.importFromAs("datetime", "tzinfo", "python.lib.datetime.TzInfo");
+		python.Syntax.importFromAs("datetime", "tzinfo", "python.lib.datetime.TzInfo");
 	}
 }

std/python/lib/io/StringIO.hx

@@ -2,9 +2,9 @@
 package python.lib.io;
 
 import python.lib.io.TextIOBase;
-import python.Macros;
+import python.Syntax;
 
-extern class StringIO extends TextIOBase 
+extern class StringIO extends TextIOBase
 {
 	public function new (?s:String):Void;
 	public function getvalue():String;
@@ -12,6 +12,6 @@ extern class StringIO extends TextIOBase
 
 
 	static function __init__ ():Void {
-		Macros.importFromAs("io", "StringIO", "python.lib.io.StringIO");
+		Syntax.importFromAs("io", "StringIO", "python.lib.io.StringIO");
 	}
 }

std/python/lib/os/Path.hx

@@ -36,7 +36,7 @@ extern class Path {
 
 	public static function dirname (path:String):String;
 
-	
+
 
 	public static function islink (path:String):Bool;
 
@@ -61,8 +61,8 @@ extern class Path {
 	public static function supports_unicode_filenames ():Bool;
 
 
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		python.Macros.importFromAs("os", "path", "python.lib.os.Path");
+		python.Syntax.importFromAs("os", "path", "python.lib.os.Path");
 	}
 }

std/python/lib/subprocess/Popen.hx

@@ -74,7 +74,7 @@ extern class Popen {
 
 	static function __init__ ():Void
 	{
-		python.Macros.importFromAs("subprocess", "Popen", "python.lib.subprocess.Popen");
+		python.Syntax.importFromAs("subprocess", "Popen", "python.lib.subprocess.Popen");
 	}
 
 }

std/python/lib/threading/Thread.hx

@@ -3,9 +3,9 @@ package python.lib.threading;
 
 extern class Thread {
 
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		python.Macros.importFromAs("threading","Thread", "python.lib.thrading.Thread");
+		python.Syntax.importFromAs("threading","Thread", "python.lib.thrading.Thread");
 	}
 
 }

std/python/lib/xml/etree/ElementTree.hx

@@ -21,7 +21,7 @@ extern class Element {
 
 	public function copy ():Element;
 
-	public function keys ():Array<String>;	
+	public function keys ():Array<String>;
 	public function items ():Array<Tup2<String, String>>;
 
 	public function iter (tag:String):PyIterable<Element>;
@@ -29,9 +29,9 @@ extern class Element {
 	public function find (match:String, namespaces:Dict<String,String> = null):Null<Element>;
 	public function findall (match:String, namespaces:Dict<String,String> = null):Array<Element>;
 
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		Macros.importFromAs("xml.etree.ElementTree", "Element", "python.lib.xml.etree.Element");
+		Syntax.importFromAs("xml.etree.ElementTree", "Element", "python.lib.xml.etree.Element");
 	}
 }
 
@@ -49,9 +49,9 @@ extern class ElementTree {
 
 
 
-	static function __init__ ():Void 
+	static function __init__ ():Void
 	{
-		Macros.importAs("xml.etree.ElementTree", "python.lib.xml.etree.ElementTree");
+		Syntax.importAs("xml.etree.ElementTree", "python.lib.xml.etree.ElementTree");
 	}
 
 }