temp fix for python macro issue

std/haxe/PythonInternal.hx

@@ -0,0 +1,211 @@
+package haxe;
+#if macro
+import haxe.macro.Context;
+import haxe.macro.Expr;
+#end
+
+class PythonInternal {
+
+	#if macro
+
+	static var _prefix = "_hx_";
+
+
+	static var _className = _prefix + "class_name";
+	static var _class = _prefix + "class";
+	static var _props = _prefix + "props";
+	static var _fields = _prefix + "fields";
+	static var _super = _prefix + "super";
+	static var _methods = _prefix + "methods";
+	static var _statics = _prefix + "statics";
+	static var _interfaces = _prefix + "interfaces";
+	static var _emptyInit = _prefix + "empty_init";
+	static var _constructs = _prefix + "constructs";
+
+	static var _classes = _prefix + "classes";
+
+	static var _dict = "__dict__";
+
+	static function _getPrefixed (x:Expr):Expr {
+		return switch (x.expr) {
+			case EConst(CString(x)): macro @:pos(Context.currentPos()) $v{_prefix + x};
+			case _ : macro @:pos(Context.currentPos()) (python.Syntax.binop($v{_prefix},"+",$x):String);
+		}
+	}
+
+
+
+	static function withPos(x:String):Expr {
+		return macro @:pos(Context.currentPos()) $v{x};
+	}
+
+	static function fieldWithPos(o:Expr, x:String):Expr {
+		return macro @:pos(Context.currentPos()) python.Syntax.field($o, $v{x});
+	}
+
+	static function has (o:Expr, field:String):Expr {
+		return macro python.internal.HxBuiltin.hasattr($o, $v{field});
+	}
+
+	#end
+
+	macro public static function getPrefixed (x:ExprOf<String>):Expr {
+		return switch (x.expr) {
+			case EConst(CString(x)): macro @:pos(Context.currentPos()) $v{_prefix + x};
+			case _ : macro @:pos(Context.currentPos()) (python.Syntax.binop($v{_prefix},"+",$x):String);
+		}
+	}
+
+	macro public static function classRegistry ():Expr {
+		return macro (python.Syntax.pythonCode($v{_classes}) : python.lib.Dict<String, Class<Dynamic>>);
+	}
+
+	macro public static function callFieldPrefixed (o:Expr, x:String, params:Array<Expr>):Expr {
+		var args = [o,macro @:pos(Context.currentPos()) $v{_prefix + x}].concat(params);
+		return macro @:pos(Context.currentPos()) python.Syntax.callField($a{args});
+	}
+
+	macro public static function fieldPrefixed (o:Expr, x:String):Expr {
+		var args = [o,macro @:pos(Context.currentPos()) $v{_prefix + x}];
+		return macro @:pos(Context.currentPos()) python.Syntax.field($a{args});
+	}
+
+	macro public static function hasAttrPrefixed (o:Expr, x:String):Expr {
+		var args = [o,macro @:pos(Context.currentPos()) $v{_prefix + x}];
+		return macro @:pos(Context.currentPos()) python.Syntax.field($a{args});
+	}
+
+
+
+	macro public static function importAsPrefixed (o:String, x:String) {
+		return macro @:pos(Context.currentPos()) python.Syntax.importAs($v{o}, $v{_prefix + x});
+	}
+
+	macro public static function prefix ():Expr {
+		return macro @:pos(Context.currentPos()) $v{_prefix};
+	}
+
+	macro public static function pythonCodePrefixed (x:String):Expr {
+		return macro python.Syntax.pythonCode($v{_prefix + x});
+	}
+
+	macro public static function hasClassName (o:Expr):Expr {
+		return has(o, _className);
+	}
+
+	macro public static function hasInterfaces (o:Expr):Expr {
+		return has(o, _interfaces);
+	}
+
+	macro public static function hasClass (o:Expr):Expr {
+		return has(o, _class);
+	}
+
+	macro public static function hasConstructs (o:Expr):Expr {
+		return has(o, _constructs);
+	}
+
+	macro public static function hasEmptyInit (o:Expr):Expr {
+		return has(o, _emptyInit);
+	}
+
+	macro public static function hasFields (o:Expr):Expr {
+		return has(o, _fields);
+	}
+
+	macro public static function hasSuper (o:Expr):Expr {
+		return has(o, _super);
+	}
+
+	macro public static function hasStatics (o:Expr):Expr {
+		return has(o, _statics);
+	}
+
+	macro public static function classNameVal ():Expr {
+		return withPos(_className);
+	}
+
+	macro public static function methodsVal ():Expr {
+		return withPos(_methods);
+	}
+
+	macro public static function classVal():Expr {
+		return withPos(_className);
+	}
+
+	macro public static function propsVal():Expr {
+		return withPos(_props);
+	}
+
+	macro public static function superVal():Expr {
+		return withPos(_super);
+	}
+
+	macro public static function interfacesVal():Expr {
+		return withPos(_interfaces);
+	}
+
+	macro public static function fieldsVal():Expr {
+		return withPos(_fields);
+	}
+
+	macro public static function staticsVal():Expr {
+		return withPos(_statics);
+	}
+
+	macro public static function constructsVal():Expr {
+		return withPos(_constructs);
+	}
+
+	macro public static function emptyInitVal():Expr {
+		return withPos(_emptyInit);
+	}
+
+	macro public static function fieldClassName (o:Expr):Expr {
+		return fieldWithPos(o, _className);
+	}
+
+	macro public static function fieldInterfaces (o:Expr):Expr {
+		return fieldWithPos(o, _interfaces);
+	}
+
+	macro public static function fieldClass (o:Expr):Expr {
+		return fieldWithPos(o, _class);
+	}
+
+	macro public static function fieldSuper (o:Expr):Expr {
+		return fieldWithPos(o, _super);
+	}
+
+	macro public static function fieldStatics (o:Expr):Expr {
+		return fieldWithPos(o, _statics);
+	}
+
+	macro public static function fieldMethods (o:Expr):Expr {
+		return fieldWithPos(o, _methods);
+	}
+
+	macro public static function fieldFields (o:Expr):Expr {
+		return fieldWithPos(o, _fields);
+	}
+
+	macro public static function fieldProps (o:Expr):Expr {
+		return fieldWithPos(o, _props);
+	}
+
+	macro public static function fieldConstructs (o:Expr):Expr {
+		return fieldWithPos(o, _constructs);
+	}
+
+	macro public static function fieldDict (o:Expr):Expr {
+		return fieldWithPos(o, _dict);
+	}
+
+	macro public static function fieldEmptyInit (o:Expr):Expr {
+		return fieldWithPos(o, _emptyInit);
+	}
+
+	macro public static function callEmptyInit (o:Expr, instance:Expr):Expr {
+		return macro @:pos(Context.currentPos()) python.Syntax.callField($o, $v{_emptyInit}, $instance);
+	}
+}

std/haxe/PythonSyntax.hx

@@ -0,0 +1,141 @@
+package haxe;
+
+#if macro
+import haxe.macro.Expr;
+import haxe.macro.Context;
+import haxe.macro.ExprTools;
+#end
+
+extern class PythonSyntax {
+
+	#if macro
+	static var self = macro haxe.PythonSyntax;
+	#end
+
+	@:noUsing
+	macro public static function importModule (module:String):haxe.macro.Expr {
+		return macro ($self.pythonCode($v{"import " + module}):Void);
+	}
+
+	@:noUsing
+	macro public static function importAs (module:String, className : String):haxe.macro.Expr{
+		var n = className.split(".").join("_");
+		var e = "import " + module + " as " + n;
+
+		return macro ($self.pythonCode($v{e}):Void);
+	}
+
+	@:noUsing
+	macro public static function newInstance (c:Expr, params:Array<Expr>):haxe.macro.Expr {
+		return macro $self._newInstance($c, $a{params});
+	}
+
+	@:noUsing
+	macro public static function pythonCode(b:ExprOf<String>, rest:Array<Expr>):Expr {
+		if (rest == null) rest = [];
+		return macro @:pos(Context.currentPos()) $self._pythonCode($b, $a{rest});
+	};
+
+	@:noUsing
+	macro public static function arrayAccess(x:Expr, rest:Array<Expr>):ExprOf<Dynamic> {
+		return macro $self._arrayAccess($x, $a{rest});
+	}
+
+	@:noUsing
+	macro public static function arrayAccessWithTrailingColon(x:Expr, rest:Array<Expr>):ExprOf<Dynamic> {
+		return macro $self._arrayAccess($x, $a{rest}, true);
+	}
+
+	macro public static function foreach <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 iter = try {
+			Context.typeof(macro $it.__iter__());
+			macro $it.__iter__().getNativeIteratorRaw();
+		} catch (e:Dynamic) {
+			macro $it.getNativeIteratorRaw();
+		};
+
+		return macro {
+			// the first 2 expressions are only used to create a typing context for the foreach construct
+			// TODO how can we get rid of them, so that they are not generated?
+			var $id = null;
+			if (false) $v = $iter.__next__();
+			$self._foreach($v, $it, $b);
+		}
+	}
+
+	@: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;
+		return macro ($self.pythonCode($v{e}):Void);
+	}
+
+	@:noUsing
+	macro public static function callField(o:Expr, field:ExprOf<String>, params:Array<Expr>):haxe.macro.Expr {
+		return macro @:pos(o.pos) $self.call($self.field($o, $field), $a{params});
+	}
+
+	@:noUsing
+	macro public static function tuple(args:Array<Expr>):Dynamic {
+		var args = macro $a{args};
+		return macro $self._tuple($args);
+	}
+
+	@:noUsing
+	macro public static function callNamedUntyped (e:Expr, args:Expr):Expr {
+		return macro @:pos(e.pos) $self._callNamedUntyped($e, $args);
+	}
+
+
+	#if !macro
+
+	@:noUsing
+	static function _newInstance(c:Dynamic, args:Array<Dynamic>):Dynamic { return null; }
+
+	@:noUsing
+	public static function isIn(a:Dynamic, b:Dynamic):Bool { return false; }
+
+	@:noUsing
+	public static function delete(a:Dynamic):Void { }
+
+	@:noUsing
+	public static function binop(a:Dynamic, op:String, b:Dynamic):Dynamic { return null; }
+
+	@:noUsing
+	public static function assign(a:Dynamic, b:Dynamic):Void { }
+
+	@:noUsing
+	public static function _pythonCode<T>(b:String, args:Array<Dynamic>):T { return null; };
+
+	@:noUsing
+	static function _arrayAccess(a:Dynamic, args:Array<Dynamic>, ?trailingColon:Bool = false):Dynamic { return null; }
+
+	@:noUsing
+	public static function arraySet(a:Dynamic, i:Dynamic, v:Dynamic):Dynamic { return null; }
+
+	@:noUsing
+	static function _foreach(id:Dynamic, it:Dynamic, block:Dynamic):Dynamic { return null; }
+
+	@:noUsing
+	static function call(e:Dynamic, args:Array<Dynamic>):Dynamic { return null; }
+
+	@:noUsing
+	public static function field (o:Dynamic, field:String):Dynamic { return null; }
+
+	@:noUsing
+	static function _tuple(args:Array<Dynamic>):Dynamic { return null; }
+
+	@:noUsing
+	public static function varArgs(args:Array<Dynamic>):Dynamic { return null; }
+
+	@:noUsing
+	static function _callNamedUntyped(e:Dynamic, args:Dynamic):Dynamic { return null; }
+
+	@:noUsing
+	public static function opPow(a:Int, b:Int):Int { return 0; }
+
+	#end
+}

std/python/Syntax.hx

@@ -1,136 +1,3 @@
 package python;
 
-#if macro
-import haxe.macro.Expr;
-import haxe.macro.Context;
-import haxe.macro.ExprTools;
-#end
-
-extern 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.pythonCode($v{"import " + module}):Void);
-	}
-
-	@:noUsing macro public static function importAs (module:String, className : String):haxe.macro.Expr
-	{
-		var n = className.split(".").join("_");
-		var e = "import " + module + " as " + n;
-
-		return macro ($self.pythonCode($v{e}):Void);
-	}
-
-	@:noUsing
-	macro public static function newInstance (c:Expr, params:Array<Expr>):haxe.macro.Expr {
-		return macro $self._newInstance($c, $a{params});
-	}
-
-	static function _newInstance(c:Dynamic, args:Array<Dynamic>):Dynamic { return null; }
-
-	@:noUsing
-	public static function isIn(a:Dynamic, b:Dynamic):Bool { return false; }
-
-	@:noUsing
-	public static function delete(a:Dynamic):Void { }
-
-	@:noUsing
-	public static function binop(a:Dynamic, op:String, b:Dynamic):Dynamic { return null; }
-
-	@:noUsing
-	public static function assign(a:Dynamic, b:Dynamic):Void { }
-
-	@:noUsing
-	macro public static function pythonCode(b:ExprOf<String>, rest:Array<Expr>):Expr {
-		if (rest == null) rest = [];
-		return macro @:pos(Context.currentPos()) $self._pythonCode($b, $a{rest});
-	};
-
-	#if !macro
-	@:noUsing
-	public static function _pythonCode<T>(b:String, args:Array<Dynamic>):T { return null; };
-	#end
-	@:noUsing
-	macro public static function arrayAccess(x:Expr, rest:Array<Expr>):ExprOf<Dynamic> {
-		return macro $self._arrayAccess($x, $a{rest});
-	}
-
-	@:noUsing
-	macro public static function arrayAccessWithTrailingColon(x:Expr, rest:Array<Expr>):ExprOf<Dynamic> {
-		return macro $self._arrayAccess($x, $a{rest}, true);
-	}
-
-	static function _arrayAccess(a:Dynamic, args:Array<Dynamic>, ?trailingColon:Bool = false):Dynamic { return null; }
-
-	@:noUsing
-	public static function arraySet(a:Dynamic, i:Dynamic, v:Dynamic):Dynamic { return null; }
-
-
-	static function _foreach(id:Dynamic, it:Dynamic, block:Dynamic):Dynamic { return null; }
-
-
-	@:noUsing
-	macro public static function foreach <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 iter = try {
-			Context.typeof(macro $it.__iter__());
-			macro $it.__iter__().getNativeIteratorRaw();
-		} catch (e:Dynamic) {
-			macro $it.getNativeIteratorRaw();
-		};
-
-
-		return macro {
-			// the first 2 expressions are only used to create a typing context for the foreach construct
-			// TODO how can we get rid of them, so that they are not generated?
-			var $id = null;
-			if (false) $v = $iter.__next__();
-			$self._foreach($v, $it, $b);
-		}
-	}
-
-	@: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;
-
-		return macro ($self.pythonCode($v{e}):Void);
-	}
-
-	@:noUsing
-	macro public static function callField(o:Expr, field:ExprOf<String>, params:Array<Expr>):haxe.macro.Expr {
-		return macro @:pos(o.pos) $self.call($self.field($o, $field), $a{params});
-	}
-
-	static function call(e:Dynamic, args:Array<Dynamic>):Dynamic { return null; }
-
-	@:noUsing
-	public static function field (o:Dynamic, field:String):Dynamic { return null; }
-
-	@:noUsing
-	macro public static function tuple(args:Array<Expr>):Dynamic {
-		var args = macro $a{args};
-		return macro $self._tuple($args);
-	}
-
-	static function _tuple(args:Array<Dynamic>):Dynamic { return null; }
-
-	@:noUsing
-	public static function varArgs(args:Array<Dynamic>):Dynamic { return null; }
-
-	macro public static function callNamedUntyped (e:Expr, args:Expr):Expr {
-		return macro @:pos(e.pos) $self._callNamedUntyped($e, $args);
-	}
-
-	static function _callNamedUntyped(e:Dynamic, args:Dynamic):Dynamic { return null; }
-
-	public static function opPow(a:Int, b:Int):Int { return 0; }
-}
+typedef Syntax = haxe.PythonSyntax;

std/python/internal/Internal.hx

@@ -1,211 +1,3 @@
 package python.internal;
-#if macro
-import haxe.macro.Context;
-import haxe.macro.Expr;
-#end
 
-class Internal {
-
-	#if macro
-
-	static var _prefix = "_hx_";
-
-
-	static var _className = _prefix + "class_name";
-	static var _class = _prefix + "class";
-	static var _props = _prefix + "props";
-	static var _fields = _prefix + "fields";
-	static var _super = _prefix + "super";
-	static var _methods = _prefix + "methods";
-	static var _statics = _prefix + "statics";
-	static var _interfaces = _prefix + "interfaces";
-	static var _emptyInit = _prefix + "empty_init";
-	static var _constructs = _prefix + "constructs";
-
-	static var _classes = _prefix + "classes";
-
-	static var _dict = "__dict__";
-
-	static function _getPrefixed (x:Expr):Expr {
-		return switch (x.expr) {
-			case EConst(CString(x)): macro @:pos(Context.currentPos()) $v{_prefix + x};
-			case _ : macro @:pos(Context.currentPos()) (python.Syntax.binop($v{_prefix},"+",$x):String);
-		}
-	}
-
-
-
-	static function withPos(x:String):Expr {
-		return macro @:pos(Context.currentPos()) $v{x};
-	}
-
-	static function fieldWithPos(o:Expr, x:String):Expr {
-		return macro @:pos(Context.currentPos()) python.Syntax.field($o, $v{x});
-	}
-
-	static function has (o:Expr, field:String):Expr {
-		return macro python.internal.HxBuiltin.hasattr($o, $v{field});
-	}
-
-	#end
-
-	macro public static function getPrefixed (x:ExprOf<String>):Expr {
-		return switch (x.expr) {
-			case EConst(CString(x)): macro @:pos(Context.currentPos()) $v{_prefix + x};
-			case _ : macro @:pos(Context.currentPos()) (python.Syntax.binop($v{_prefix},"+",$x):String);
-		}
-	}
-
-	macro public static function classRegistry ():Expr {
-		return macro (python.Syntax.pythonCode($v{_classes}) : python.lib.Dict<String, Class<Dynamic>>);
-	}
-
-	macro public static function callFieldPrefixed (o:Expr, x:String, params:Array<Expr>):Expr {
-		var args = [o,macro @:pos(Context.currentPos()) $v{_prefix + x}].concat(params);
-		return macro @:pos(Context.currentPos()) python.Syntax.callField($a{args});
-	}
-
-	macro public static function fieldPrefixed (o:Expr, x:String):Expr {
-		var args = [o,macro @:pos(Context.currentPos()) $v{_prefix + x}];
-		return macro @:pos(Context.currentPos()) python.Syntax.field($a{args});
-	}
-
-	macro public static function hasAttrPrefixed (o:Expr, x:String):Expr {
-		var args = [o,macro @:pos(Context.currentPos()) $v{_prefix + x}];
-		return macro @:pos(Context.currentPos()) python.Syntax.field($a{args});
-	}
-
-
-
-	macro public static function importAsPrefixed (o:String, x:String) {
-		return macro @:pos(Context.currentPos()) python.Syntax.importAs($v{o}, $v{_prefix + x});
-	}
-
-	macro public static function prefix ():Expr {
-		return macro @:pos(Context.currentPos()) $v{_prefix};
-	}
-
-	macro public static function pythonCodePrefixed (x:String):Expr {
-		return macro python.Syntax.pythonCode($v{_prefix + x});
-	}
-
-	macro public static function hasClassName (o:Expr):Expr {
-		return has(o, _className);
-	}
-
-	macro public static function hasInterfaces (o:Expr):Expr {
-		return has(o, _interfaces);
-	}
-
-	macro public static function hasClass (o:Expr):Expr {
-		return has(o, _class);
-	}
-
-	macro public static function hasConstructs (o:Expr):Expr {
-		return has(o, _constructs);
-	}
-
-	macro public static function hasEmptyInit (o:Expr):Expr {
-		return has(o, _emptyInit);
-	}
-
-	macro public static function hasFields (o:Expr):Expr {
-		return has(o, _fields);
-	}
-
-	macro public static function hasSuper (o:Expr):Expr {
-		return has(o, _super);
-	}
-
-	macro public static function hasStatics (o:Expr):Expr {
-		return has(o, _statics);
-	}
-
-	macro public static function classNameVal ():Expr {
-		return withPos(_className);
-	}
-
-	macro public static function methodsVal ():Expr {
-		return withPos(_methods);
-	}
-
-	macro public static function classVal():Expr {
-		return withPos(_className);
-	}
-
-	macro public static function propsVal():Expr {
-		return withPos(_props);
-	}
-
-	macro public static function superVal():Expr {
-		return withPos(_super);
-	}
-
-	macro public static function interfacesVal():Expr {
-		return withPos(_interfaces);
-	}
-
-	macro public static function fieldsVal():Expr {
-		return withPos(_fields);
-	}
-
-	macro public static function staticsVal():Expr {
-		return withPos(_statics);
-	}
-
-	macro public static function constructsVal():Expr {
-		return withPos(_constructs);
-	}
-
-	macro public static function emptyInitVal():Expr {
-		return withPos(_emptyInit);
-	}
-
-	macro public static function fieldClassName (o:Expr):Expr {
-		return fieldWithPos(o, _className);
-	}
-
-	macro public static function fieldInterfaces (o:Expr):Expr {
-		return fieldWithPos(o, _interfaces);
-	}
-
-	macro public static function fieldClass (o:Expr):Expr {
-		return fieldWithPos(o, _class);
-	}
-
-	macro public static function fieldSuper (o:Expr):Expr {
-		return fieldWithPos(o, _super);
-	}
-
-	macro public static function fieldStatics (o:Expr):Expr {
-		return fieldWithPos(o, _statics);
-	}
-
-	macro public static function fieldMethods (o:Expr):Expr {
-		return fieldWithPos(o, _methods);
-	}
-
-	macro public static function fieldFields (o:Expr):Expr {
-		return fieldWithPos(o, _fields);
-	}
-
-	macro public static function fieldProps (o:Expr):Expr {
-		return fieldWithPos(o, _props);
-	}
-
-	macro public static function fieldConstructs (o:Expr):Expr {
-		return fieldWithPos(o, _constructs);
-	}
-
-	macro public static function fieldDict (o:Expr):Expr {
-		return fieldWithPos(o, _dict);
-	}
-
-	macro public static function fieldEmptyInit (o:Expr):Expr {
-		return fieldWithPos(o, _emptyInit);
-	}
-
-	macro public static function callEmptyInit (o:Expr, instance:Expr):Expr {
-		return macro @:pos(Context.currentPos()) python.Syntax.callField($o, $v{_emptyInit}, $instance);
-	}
-}
+typedef Internal = haxe.PythonInternal;

std/python/internal/StringImpl.hx

@@ -3,8 +3,6 @@ package python.internal;
 import python.internal.Internal;
 import python.internal.HxBuiltin;
 
-
-
 @:keep
 @:native("HxString")
 class StringImpl {