use Internal class to access internal identifiers

std/python/Boot.hx

@@ -3,6 +3,7 @@ package python;
 
 
 import python.internal.ArrayImpl;
+import python.internal.Internal;
 import python.internal.StringImpl;
 import python.internal.EnumImpl;
 import python.internal.HxOverrides;
@@ -11,7 +12,6 @@ import python.internal.AnonObject;
 
 import python.Syntax;
 
-
 private extern class Set <T>
 {
 	public inline function has (v:T):Bool
@@ -40,12 +40,13 @@ import math as _hx_math
 @:keep class Boot {
 
 	@:keep static function __init__ () {
-		Syntax.importAs("inspect", "_hx_boot_inspect");
-		Boot.inspect = Syntax.pythonCode("_hx_boot_inspect");
+		Internal.importAsPrefixed("inspect", "boot_inspect");
+		Boot.inspect = Internal.pythonCodePrefixed("boot_inspect");
 
-		Boot.builtin = Syntax.pythonCode("_hx_builtin");
+		Boot.builtin = Internal.pythonCodePrefixed("builtin");
 	}
 
+
 	inline static function mkSet <T>(a:Array<T>):Set<T> return Syntax.callField(builtin, "set", a);
 
 	static var keywords:Set<String> = mkSet(
@@ -229,6 +230,7 @@ import math as _hx_math
 			}
 			if (isInstance(o, Enum)) {
 
+				var o:EnumImpl = o;
 
 				var l = builtinLen(o.params);
 				var hasParams = l > 0;
@@ -248,21 +250,21 @@ import math as _hx_math
 			}
 
 
-			if (builtinHasAttr(o, "_hx_class_name") && Syntax.field(Syntax.field(o, "__class__"), "__name__") != "type") {
+			if (builtinHasAttr(o, Internal.classNameVal()) && 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")}'];
 
-				var toStr = o._hx_class_name + "( " + arrayJoin(fieldsStr, ", ") + " )";
+				var toStr = Internal.fieldClassName(o) + "( " + arrayJoin(fieldsStr, ", ") + " )";
 				return toStr;
 			}
 
-			if (builtinHasAttr(o, "_hx_class_name") && Syntax.field(Syntax.field(o, "__class__"), "__name__") == "type") {
+			if (builtinHasAttr(o, Internal.classNameVal()) && 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")}'];
 
-				var toStr = "#" + o._hx_class_name + "( " + arrayJoin(fieldsStr, ", ") + " )";
+				var toStr = "#" + Internal.fieldClassName(o) + "( " + arrayJoin(fieldsStr, ", ") + " )";
 				return toStr;
 			}
 			if (o == String) {
@@ -304,16 +306,16 @@ import math as _hx_math
 		var a = [];
 		if (o != null)
 		{
-			if (builtinHasAttr(o, "_hx_fields"))
+			if (builtinHasAttr(o, Internal.fieldsVal()))
 			{
-				var fields:Array<String> = Syntax.field(o, "_hx_fields");
+				var fields:Array<String> = Internal.fieldFields(o);
 				return fields.copy();
 			}
 			if (isInstance(o, AnonObject))
 			{
 
 				var d:Dynamic = Syntax.field(o, "__dict__");
-				var keys  = d.keys();
+				var keys = d.keys();
 				var handler = unhandleKeywords;
 
 				Syntax.pythonCode("for k in keys:");
@@ -323,8 +325,8 @@ import math as _hx_math
 			{
 				var a = [];
 				var d:Dynamic = Syntax.field(o, "__dict__");
-				var keys  = d.keys();
-				Syntax.pythonCode("for k in keys:");
+				var keys1  = d.keys();
+				Syntax.pythonCode("for k in keys1:");
 				Syntax.pythonCode("	a.append(k)");
 
 			}
@@ -384,9 +386,9 @@ import math as _hx_math
 
 
 	static function getInstanceFields( c : Class<Dynamic> ) : Array<String> {
-		var f = if (builtinHasAttr(c, "_hx_fields")) {
-			var x:Array<String> = Syntax.field(c, "_hx_fields");
-			var x2:Array<String> = Syntax.field(c, "_hx_methods");
+		var f = if (builtinHasAttr(c, Internal.fieldsVal())) {
+			var x:Array<String> = Internal.fieldFields(c);
+			var x2:Array<String> = Internal.fieldMethods(c);
 			x.concat(x2);
 		} else {
 			[];
@@ -415,8 +417,8 @@ import math as _hx_math
 			return null;
 
 		try {
-			if (builtinHasAttr(c, "_hx_super")) {
-				return Syntax.field(c, "_hx_super");
+			if (builtinHasAttr(c, Internal.superVal())) {
+				return Internal.fieldSuper(c);
 			}
 			return null;
 		} catch (e:Dynamic) {
@@ -427,8 +429,8 @@ import math as _hx_math
 	}
 
 	static function getClassFields( c : Class<Dynamic> ) : Array<String> {
-		if (builtinHasAttr(c, "_hx_statics")) {
-			var x:Array<String> = Syntax.field(c, "_hx_statics");
+		if (builtinHasAttr(c, Internal.staticsVal()) ) {
+			var x:Array<String> = Internal.fieldStatics(c);
 			return x.copy();
 		} else {
 			return [];
@@ -440,14 +442,14 @@ import math as _hx_math
 	static inline function handleKeywords(name:String):String
 	{
 		if (keywords.has(name)) {
-			return "_hx_" + name;
+			return Internal.getPrefixed(name);
 		}
 		return name;
 	}
 
 	static function unhandleKeywords(name:String):String
 	{
-		if (name.substr(0,4) == "_hx_") {
+		if (name.substr(0,4) == Internal.prefix()) {
 			var real = name.substr(4);
 			if (keywords.has(real)) return real;
 		}

std/python/_std/Type.hx

@@ -1,5 +1,6 @@
 import python.internal.AnonObject;
 import python.internal.EnumImpl;
+import python.internal.Internal;
 import python.lib.Builtin;
 import python.Syntax;
 
@@ -51,8 +52,8 @@ enum ValueType {
 
 		if (python.Boot.isAnonObject(o)) return null;
 
-		if (Builtin.hasattr(o, "_hx_class")) {
-			return Syntax.field(o, "_hx_class");
+		if (Builtin.hasattr(o, Internal.classVal())) {
+			return Internal.fieldClass(o);
 		}
 		if (Builtin.hasattr(o, "__class__")) {
 			return Syntax.field(o, "__class__");
@@ -76,8 +77,8 @@ enum ValueType {
 	public static function getClassName( c : Class<Dynamic> ) : String
 	{
 
-		if (Builtin.hasattr(c, "_hx_class_name")) {
-			return Syntax.field(c, "_hx_class_name");
+		if (Builtin.hasattr(c, Internal.classNameVal())) {
+			return Internal.fieldClassName(c);
 		} else {
 			// not a haxe class
 			if (c == Array) return "Array";
@@ -97,16 +98,16 @@ enum ValueType {
 	}
 
 	public static function getEnumName( e : Enum<Dynamic> ) : String {
-		return Syntax.field(e, "_hx_class_name");
+		return Internal.fieldClassName(e);
 	}
 
 	public static function resolveClass( name : String ) : Class<Dynamic>
 	{
-
 		if (name == "Array") return Array;
 		if (name == "Math") return Math;
 		if (name == "String") return String;
-		var cl : Class<Dynamic> = (untyped _hx_classes : python.lib.Types.Dict<String, Class<Dynamic>>).get(name, null);
+
+		var cl : Class<Dynamic> = Internal.classRegistry().get(name, null);
 		// ensure that this is a class
 		if( cl == null || !python.Boot.isClass(cl) )
 				return null;
@@ -116,7 +117,7 @@ enum ValueType {
 	public static function resolveEnum( name : String ) : Enum<Dynamic> {
 		if (name == "Bool") return cast Bool;
 		var o = resolveClass(name);
-		return if (Builtin.hasattr(o, "_hx_constructs")) cast o else null;
+		return if (Builtin.hasattr(o, Internal.constructsVal())) cast o else null;
 	}
 
 	public static function createInstance<T>( cl : Class<T>, args : Array<Dynamic> ) : T
@@ -157,8 +158,8 @@ enum ValueType {
 			if (sc != null) {
 				callInit(sc);
 			}
-			if (Builtin.hasattr(cl, "_hx_empty_init")) {
-				Syntax.callField(cl, "_hx_empty_init", i);
+			if (Builtin.hasattr(cl, Internal.emptyInitVal())) {
+				Internal.callEmptyInit(cl, i);
 			}
 		}
 		callInit(cl);
@@ -182,7 +183,7 @@ enum ValueType {
 
 	public static function createEnumIndex<T>( e : Enum<T>, index : Int, ?params : Array<Dynamic> ) : T {
 
-		var c : String = Syntax.field(e, "_hx_constructs")[index];
+		var c : String = Internal.fieldConstructs(e)[index];
 		if( c == null ) throw index+" is not a valid enum constructor index";
 		return createEnum(e,c,params);
 	}
@@ -196,8 +197,8 @@ enum ValueType {
 	}
 
 	public static function getEnumConstructs( e : Enum<Dynamic> ) : Array<String> {
-		if (Builtin.hasattr(e, "_hx_constructs")) {
-			var x:Array<String> = Syntax.field(e, "_hx_constructs");
+		if (Builtin.hasattr(e, Internal.constructsVal())) {
+			var x:Array<String> = Internal.fieldConstructs(e);
 			return x.copy();
 		} else {
 			return [];
@@ -225,7 +226,7 @@ enum ValueType {
 		else if (Builtin.isinstance(v, Enum)) {
 			return TEnum(Syntax.field(v, "__class__"));
 		}
-		else if (Builtin.isinstance(v, Builtin.type) || Builtin.hasattr(v, "_hx_class")) {
+		else if (Builtin.isinstance(v, Builtin.type) || Builtin.hasattr(v, Internal.classVal())) {
 			return TClass(Syntax.field(v, "__class__"));
 		} else if (Builtin.callable(v)) {
 			return TFunction;
@@ -254,7 +255,7 @@ enum ValueType {
 					return false;
 			//var e = Type.getClass(a);
 
-			if( Syntax.field(a, "_hx_class") != Syntax.field(b, "_hx_class"))
+			if( Internal.fieldClass(a) != Internal.fieldClass(b))
 				return false;
 		} catch( e : Dynamic ) {
 			return false;

std/python/internal/Internal.hx

@@ -0,0 +1,180 @@
+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 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()) $v{_prefix} + $x;
+		}
+	}
+
+
+
+	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()) Syntax.field($o, $v{x});
+	}
+	#end
+
+	macro public static function classRegistry ():Expr
+	{
+		return macro (python.internal.Internal.pythonCodePrefixed("classes") : python.lib.Types.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 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()) $v{_prefix} + $x;
+		}
+
+	}
+
+	macro public static function importAsPrefixed (o:String, x:String) {
+		return macro @:pos(Context.currentPos()) 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 Syntax.pythonCode($v{_prefix + x});
+	}
+
+	macro public static function fieldClassName (o:Expr):Expr {
+
+		return macro Syntax.field($o, $v{_className});
+	}
+
+	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 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 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);
+	}
+
+
+
+
+
+}