more cleanup

std/python/_std/Std.hx

@@ -22,6 +22,7 @@
 
 package;
 
+import python.internal.Internal;
 import python.lib.Builtin;
 import python.lib.Inspect;
 import python.Boot;
@@ -71,7 +72,7 @@ import python.Boot;
 		if ( t == (python.Syntax.pythonCode("str"))) {
 			return Builtin.isinstance(v, String);
 		}
-		if (t == Enum && Inspect.isclass(v) && Builtin.hasattr(v, "_hx_constructs")) return true;
+		if (t == Enum && Inspect.isclass(v) && Internal.hasConstructs(v)) return true;
 
 		if (t == Enum) return false;
 
@@ -81,7 +82,7 @@ import python.Boot;
 
 		if (Builtin.isinstance(v, Date)) return false;
 
-		if (t == Class && !Builtin.isinstance(v, untyped Enum) && Inspect.isclass(v) && Builtin.hasattr(v, "_hx_class_name") && !Builtin.hasattr(v, "_hx_constructs")) return true;
+		if (t == Class && !Builtin.isinstance(v, untyped Enum) && Inspect.isclass(v) && Internal.hasClassName(v) && !Internal.hasConstructs(v)) return true;
 
 		if (t == Class) return false; // && !Builtin.isinstance(v, untyped Enum) && Builtin.hasattr(v, "__class__") && untyped Builtin.hasattr(v.__class__, "_hx_class_name") && !untyped Builtin.hasattr(v.__class__, "_hx_constructs")) return true;
 
@@ -92,7 +93,7 @@ import python.Boot;
 
 			function loop (intf)
 			{
-				var f:Array<Dynamic> = if (Builtin.hasattr(intf,"_hx_interfaces")) Builtin.getattr(intf, "_hx_interfaces") else [];
+				var f:Array<Dynamic> = if (Internal.hasInterfaces(intf)) Internal.fieldInterfaces(intf) else [];
 				if (f != null) {
 					for (i in f) {
 						if ( i == t) {

std/python/_std/Type.hx

@@ -42,12 +42,9 @@ enum ValueType {
 
 	public static function getClass<T>( o : T ) : Class<T> {
 
-
-
 		if( o == null )
 			return null;
 
-
 		if (python.Boot.isClass(o)) return null;
 
 		if (python.Boot.isAnonObject(o)) return null;
@@ -77,20 +74,17 @@ enum ValueType {
 		if (Internal.hasClassName(c)) {
 			return Internal.fieldClassName(c);
 		} else {
-			// not a haxe class
+			// it's not a haxe class
 			if (c == Array) return "Array";
 			if (c == Math) return "Math";
 			if (c == String) return "String";
 
 			try {
 				var s :String = Syntax.field(c, "__name__");
-			} catch (e:Dynamic) {
-
-			}
+			} catch (e:Dynamic) {}
 		}
 		var res = null;
 
-
 		return res;
 	}
 
@@ -107,7 +101,7 @@ enum ValueType {
 		var cl : Class<Dynamic> = Internal.classRegistry().get(name, null);
 		// ensure that this is a class
 		if( cl == null || !python.Boot.isClass(cl) )
-				return null;
+			return null;
 		return cl;
 	}
 
@@ -155,7 +149,7 @@ enum ValueType {
 			if (sc != null) {
 				callInit(sc);
 			}
-			if (Builtin.hasattr(cl, Internal.emptyInitVal())) {
+			if (Internal.hasEmptyInit(cl)) {
 				Internal.callEmptyInit(cl, i);
 			}
 		}
@@ -185,11 +179,11 @@ enum ValueType {
 		return createEnum(e,c,params);
 	}
 
-	public static function getInstanceFields( c : Class<Dynamic> ) : Array<String> {
+	public static inline function getInstanceFields( c : Class<Dynamic> ) : Array<String> {
 		return python.Boot.getInstanceFields(c);
 	}
 
-	public static function getClassFields( c : Class<Dynamic> ) : Array<String> {
+	public static inline function getClassFields( c : Class<Dynamic> ) : Array<String> {
 		return python.Boot.getClassFields(c);
 	}
 
@@ -223,7 +217,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, Internal.classVal())) {
+		else if (Builtin.isinstance(v, Builtin.type) || Internal.hasClass(v)) {
 			return TClass(Syntax.field(v, "__class__"));
 		} else if (Builtin.callable(v)) {
 			return TFunction;
@@ -243,14 +237,13 @@ enum ValueType {
 			if (b == null && a != b) return false;
 			if( asEnumImpl(a).tag != asEnumImpl(b).tag )
 				return false;
-			var p1:Array<Dynamic> = asEnumImpl(a).params;
-			var p2:Array<Dynamic> = asEnumImpl(b).params;
+			var p1 = asEnumImpl(a).params;
+			var p2 = asEnumImpl(b).params;
 			if (p1.length != p2.length) return false;
 
 			for( i in 0...p1.length )
 				if( !enumEq(p1[i],p2[i]) )
 					return false;
-			//var e = Type.getClass(a);
 
 			if( Internal.fieldClass(a) != Internal.fieldClass(b))
 				return false;

std/python/internal/ArrayImpl.hx

@@ -31,7 +31,7 @@ private abstract Builtin(Dynamic) {}
 @:keep
 class ArrayImpl {
 
-	static inline function builtin():Builtin return Syntax.pythonCode("_hx_builtin");
+	static inline function builtin():Builtin return Internal.builtin();
 
 	public static inline function get_length <T>(x:Array<T>):Int return Syntax.callField(builtin(), "len", x);
 

std/python/internal/Internal.hx

@@ -37,7 +37,7 @@ class Internal {
 	}
 
 	static function fieldWithPos(o:Expr, x:String):Expr {
-		return macro @:pos(Context.currentPos()) Syntax.field($o, $v{x});
+		return macro @:pos(Context.currentPos()) python.Syntax.field($o, $v{x});
 	}
 
 	static function has (o:Expr, field:String):Expr {
@@ -46,6 +46,10 @@ class Internal {
 
 	#end
 
+	macro public static function builtin ():Expr {
+		return macro (python.Syntax.pythonCode($v{_builtin}):Dynamic);
+	}
+
 	macro public static function classRegistry ():Expr {
 		return macro (python.Syntax.pythonCode($v{_classes}) : python.lib.Types.Dict<String, Class<Dynamic>>);
 	}
@@ -70,11 +74,10 @@ class Internal {
 			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});
+		return macro @:pos(Context.currentPos()) python.Syntax.importAs($v{o}, $v{_prefix + x});
 	}
 
 	macro public static function prefix ():Expr {
@@ -82,17 +85,17 @@ class Internal {
 	}
 
 	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});
+		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);
 	}
@@ -101,6 +104,10 @@ class Internal {
 		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);
 	}
@@ -113,8 +120,6 @@ class Internal {
 		return has(o, _statics);
 	}
 
-
-
 	macro public static function classNameVal ():Expr {
 		return withPos(_className);
 	}
@@ -155,6 +160,10 @@ class Internal {
 		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);
 	}
@@ -170,12 +179,15 @@ class Internal {
 	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);
 	}

std/python/internal/StringImpl.hx

@@ -1,14 +1,13 @@
 package python.internal;
 
+import python.internal.Internal;
+
 
 @:keep
 @:native("HxString")
 class StringImpl {
 
-
-
-	static inline function builtin ():Dynamic return Syntax.pythonCode("_hx_builtin");
-
+	static inline function builtin ():Dynamic return Internal.builtin();
 
 	public static function split (s:String, d:String) {
 		return if (d == "") Syntax.field(builtin(), "list")(s) else Syntax.callField(s, "split", d);
@@ -19,9 +18,11 @@ class StringImpl {
 			if (s == null || s.length == 0 || index < 0 || index >= s.length) null
 			else Syntax.callField(builtin(), "ord", Syntax.arrayAccess(s, index));
 	}
+
 	public static inline function charAt(s:String, index:Int) {
 		return if (index < 0 || index >= s.length) "" else Syntax.arrayAccess(s,index);
 	}
+
 	public static inline function lastIndexOf(s:String, str:String, ?startIndex:Int):Int {
 		if (startIndex == null) {
 			return Syntax.callField(s, "rfind", str, 0, s.length);