more cleanup

std/python/Boot.hx

@@ -171,12 +171,8 @@ import math as _hx_math
 			}
 		}
 
-
 		if (inspectIsFunction(o) || inspectIsMethod(o)) return "<function>";
 
-
-
-
 		if (isInstance(o, Array))
 		{
 			var o1:Array<Dynamic> = o;
@@ -250,7 +246,7 @@ import math as _hx_math
 			}
 
 
-			if (builtinHasAttr(o, Internal.classNameVal()) && Syntax.field(Syntax.field(o, "__class__"), "__name__") != "type") {
+			if (Internal.hasClassName(o) && 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 +255,7 @@ import math as _hx_math
 				return toStr;
 			}
 
-			if (builtinHasAttr(o, Internal.classNameVal()) && Syntax.field(Syntax.field(o, "__class__"), "__name__") == "type") {
+			if (Internal.hasClassName(o) && 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")}'];
@@ -306,7 +302,7 @@ import math as _hx_math
 		var a = [];
 		if (o != null)
 		{
-			if (builtinHasAttr(o, Internal.fieldsVal()))
+			if (Internal.hasFields(o))
 			{
 				var fields:Array<String> = Internal.fieldFields(o);
 				return fields.copy();
@@ -386,7 +382,7 @@ import math as _hx_math
 
 
 	static function getInstanceFields( c : Class<Dynamic> ) : Array<String> {
-		var f = if (builtinHasAttr(c, Internal.fieldsVal())) {
+		var f = if (Internal.hasFields(c)) {
 			var x:Array<String> = Internal.fieldFields(c);
 			var x2:Array<String> = Internal.fieldMethods(c);
 			x.concat(x2);
@@ -417,7 +413,7 @@ import math as _hx_math
 			return null;
 
 		try {
-			if (builtinHasAttr(c, Internal.superVal())) {
+			if (Internal.hasSuper(c)) {
 				return Internal.fieldSuper(c);
 			}
 			return null;
@@ -429,7 +425,7 @@ import math as _hx_math
 	}
 
 	static function getClassFields( c : Class<Dynamic> ) : Array<String> {
-		if (builtinHasAttr(c, Internal.staticsVal()) ) {
+		if (Internal.hasStatics(c)) {
 			var x:Array<String> = Internal.fieldStatics(c);
 			return x.copy();
 		} else {
@@ -447,10 +443,12 @@ import math as _hx_math
 		return name;
 	}
 
+	static var prefixLength = Internal.prefix().length;
+
 	static function unhandleKeywords(name:String):String
 	{
-		if (name.substr(0,4) == Internal.prefix()) {
-			var real = name.substr(4);
+		if (name.substr(0,prefixLength) == Internal.prefix()) {
+			var real = name.substr(prefixLength);
 			if (keywords.has(real)) return real;
 		}
 		return name;

std/python/_std/Type.hx

@@ -52,7 +52,7 @@ enum ValueType {
 
 		if (python.Boot.isAnonObject(o)) return null;
 
-		if (Builtin.hasattr(o, Internal.classVal())) {
+		if (Internal.hasClass(o)) {
 			return Internal.fieldClass(o);
 		}
 		if (Builtin.hasattr(o, "__class__")) {
@@ -73,11 +73,8 @@ enum ValueType {
 
 	}
 
-
-	public static function getClassName( c : Class<Dynamic> ) : String
-	{
-
-		if (Builtin.hasattr(c, Internal.classNameVal())) {
+	public static function getClassName( c : Class<Dynamic> ) : String {
+		if (Internal.hasClassName(c)) {
 			return Internal.fieldClassName(c);
 		} else {
 			// not a haxe class
@@ -117,7 +114,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, Internal.constructsVal())) cast o else null;
+		return if (Internal.hasConstructs(o)) cast o else null;
 	}
 
 	public static function createInstance<T>( cl : Class<T>, args : Array<Dynamic> ) : T

std/python/internal/Internal.hx

@@ -7,9 +7,10 @@ import haxe.macro.Expr;
 class Internal {
 
 	#if macro
-	static var _prefix = "_hx_";
 
+	static var _prefix = "_hx_";
 
+	static var _builtin = _prefix + "builtin";
 
 	static var _className = _prefix + "class_name";
 	static var _class = _prefix + "class";
@@ -22,52 +23,49 @@ class Internal {
 	static var _emptyInit = _prefix + "empty_init";
 	static var _constructs = _prefix + "constructs";
 
-	static function _getPrefixed (x:Expr):Expr
-	{
+	static var _classes = _prefix + "classes";
+
+	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
-	{
+	static function withPos(x:String):Expr {
 		return macro @:pos(Context.currentPos()) $v{x};
 	}
 
-	static function fieldWithPos(o:Expr, x:String):Expr
-	{
+	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>>);
+	static function has (o:Expr, field:String):Expr {
+		return macro python.Syntax.pythonCode($v{_builtin}).hasattr($o, $v{field});
+	}
+
+	#end
 
+	macro public static function classRegistry ():Expr {
+		return macro (python.Syntax.pythonCode($v{_classes}) : python.lib.Types.Dict<String, Class<Dynamic>>);
 	}
 
-	macro public static function callFieldPrefixed (o:Expr, x:String, params:Array<Expr>):Expr
-	{
+	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
-	{
+
+	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
-	{
+
+	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
-	{
+	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;
@@ -79,60 +77,81 @@ class Internal {
 		return macro @:pos(Context.currentPos()) Syntax.importAs($v{o}, $v{_prefix + x});
 	}
 
-	macro public static function prefix ():Expr
-	{
+	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 {
+	macro public static function hasClassName (o:Expr):Expr {
+		return has(o, _className);
+	}
+
+	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 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 {
 
+	macro public static function methodsVal ():Expr {
 		return withPos(_methods);
 	}
 
 	macro public static function classVal():Expr {
-
 		return withPos(_className);
 	}
-	macro public static function propsVal():Expr {
 
+	macro public static function propsVal():Expr {
 		return withPos(_props);
 	}
-	macro public static function superVal():Expr
-	{
+
+	macro public static function superVal():Expr {
 		return withPos(_super);
 	}
-	macro public static function interfacesVal():Expr
-	{
+
+	macro public static function interfacesVal():Expr {
 		return withPos(_interfaces);
 	}
-	macro public static function fieldsVal():Expr
-	{
+
+	macro public static function fieldsVal():Expr {
 		return withPos(_fields);
 	}
-	macro public static function staticsVal():Expr
-	{
+
+	macro public static function staticsVal():Expr {
 		return withPos(_statics);
 	}
-	macro public static function constructsVal():Expr
-	{
+
+	macro public static function constructsVal():Expr {
 		return withPos(_constructs);
 	}
-	macro public static function emptyInitVal():Expr
-	{
+
+	macro public static function emptyInitVal():Expr {
 		return withPos(_emptyInit);
 	}
 
@@ -172,9 +191,4 @@ class Internal {
 	macro public static function callEmptyInit (o:Expr, instance:Expr):Expr {
 		return macro @:pos(Context.currentPos()) python.Syntax.callField($o, $v{_emptyInit}, $instance);
 	}
-
-
-
-
-
 }