get rid of Reflection code generated by Boot,ArrayImpl and StringImpl, remove Dependency from Dict to Reflect

std/python/Boot.hx

@@ -17,7 +17,9 @@ private extern class Set<T> {
 	}
 }
 
-@:pythonImport("math") private extern class Math {}
+@:pythonImport("math") private extern class Math {
+	public static function floor (x:Float):Int;
+}
 @:pythonImport("inspect") private extern class Inspect {}
 
 typedef HxClassBase = {
@@ -95,18 +97,11 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 @:preCode("_hx_classes = _hx_ClassRegistry()")
 @:keep class Boot {
 
-	static function __init__ () {
-
-		Boot.inspect = Inspect;
-		Boot.math = Math;
-		Boot.builtin = HxBuiltin.instance();
-	}
-
 	static inline function mathRound (v:Float) {
-		return math.floor(v + 0.5);
+		return Math.floor(v + 0.5);
 	}
 
-	inline static function mkSet <T>(a:Array<T>):Set<T> return Syntax.callField(builtin, "set", a);
+	inline static function mkSet <T>(a:Array<T>):Set<T> return Syntax.callField(HxBuiltin, "set", a);
 
 	static var keywords:Set<String> = mkSet(
 	[
@@ -125,70 +120,67 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 	}
 
 	inline static function isInstance(o:Dynamic, x:Dynamic):Bool {
-		return Syntax.callField(builtin, "isinstance", o, x);
+		return HxBuiltin.isinstance(o,x);
 	}
 
 	inline static function builtinStr(o:Dynamic):String {
-		return Syntax.callField(builtin, "str", o);
+		return HxBuiltin.str(o);
 	}
 
 	inline static function builtinHasAttr(o:Dynamic, x:String):Bool {
-		return Syntax.callField(builtin, "hasattr", o, x);
+		return Syntax.callField(HxBuiltin, "hasattr", o, x);
 	}
 
 	inline static function builtinGetAttr(o:Dynamic, x:String):Dynamic {
-		return Syntax.callField(builtin, "getattr", o, x);
+		return Syntax.callField(HxBuiltin, "getattr", o, x);
 	}
 
 	inline static function isPyBool(o:Dynamic):Bool {
-		return isInstance(o, Syntax.field(builtin, "bool"));
+		return isInstance(o, Syntax.field(HxBuiltin, "bool"));
 	}
 
 	inline static function isPyInt(o:Dynamic):Bool {
-		return isInstance(o, Syntax.field(builtin, "int"));
+		return isInstance(o, Syntax.field(HxBuiltin, "int"));
 	}
 
 	inline static function isPyFloat(o:Dynamic):Bool {
-		return isInstance(o, Syntax.field(builtin, "float"));
+		return isInstance(o, Syntax.field(HxBuiltin, "float"));
 	}
 
 	inline static function builtinLen(o:Dynamic):Int {
-		return Syntax.callField(builtin, "len", o);
+		return Syntax.callField(HxBuiltin, "len", o);
 	}
 
 	inline static function builtinInt(o:Dynamic):Int {
-		return Syntax.callField(builtin, "int", o);
+		return Syntax.callField(HxBuiltin, "int", o);
 	}
 
 	inline static function builtinCallable(o:Dynamic):Bool {
-		return Syntax.callField(builtin, "callable", o);
+		return Syntax.callField(HxBuiltin, "callable", o);
 	}
 
 	inline static function inspectGetMembers(o:Dynamic, f:String->Bool):Void {
-		Syntax.callField(inspect, "getmembers", o, f);
+		Syntax.callField(Inspect, "getmembers", o, f);
 	}
 
 	inline static function inspectIsClass(o:Dynamic):Bool {
-		return Syntax.callField(inspect, "isclass", o);
+		return Syntax.callField(Inspect, "isclass", o);
 	}
 
 	inline static function inspectIsFunction(o:Dynamic):Bool {
-		return Syntax.callField(inspect, "isclass", o);
+		return Syntax.callField(Inspect, "isclass", o);
 	}
 
 	inline static function inspectIsMethod(o:Dynamic):Bool {
-		return Syntax.callField(inspect, "isclass", o);
+		return Syntax.callField(Inspect, "isclass", o);
 	}
 
-	static var builtin:Dynamic;
-	static var inspect:Dynamic;
-	static var math:Dynamic;
 
 	static inline function isClass(o:Dynamic) : Bool {
 		return o != null && (o == String || inspectIsClass(o));
 	}
 
-	static inline function isAnonObject (o:Dynamic) {
+	static function isAnonObject (o:Dynamic) {
 		return isInstance(o, AnonObject);
 	}
 
@@ -252,7 +244,7 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 		}
 		try {
 			if (builtinHasAttr(o, "toString")) {
-				return o.toString();
+				return Syntax.callField(o, "toString");
 			}
 		} catch (e:Dynamic) {
 
@@ -367,8 +359,8 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 			}
 			if (isInstance(o, AnonObject)) {
 
-				var d:Dynamic = Syntax.field(o, "__dict__");
-				var keys = d.keys();
+				var d = Syntax.field(o, "__dict__");
+				var keys = Syntax.callField(d, "keys");
 				var handler = unhandleKeywords;
 
 				Syntax.pythonCode("for k in keys:");
@@ -376,8 +368,8 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 			}
 			else if (builtinHasAttr(o, "__dict__")) {
 				var a = [];
-				var d:Dynamic = Syntax.field(o, "__dict__");
-				var keys1  = d.keys();
+				var d = Syntax.field(o, "__dict__");
+				var keys1  = Syntax.callField(d, "keys");
 				Syntax.pythonCode("for k in keys1:");
 				Syntax.pythonCode("	a.append(k)");
 

std/python/Lib.hx

@@ -1,5 +1,7 @@
 package python;
 
+import python.internal.AnonObject;
+import python.internal.HxBuiltin;
 import python.lib.Dict;
 import python.NativeStringTools;
 
@@ -23,16 +25,17 @@ class Lib {
 
 	public static function dictToAnon (v:Dict<String, Dynamic>):Dynamic
 	{
-		var o = {};
-		Syntax.assign(Syntax.field(o, "__dict__"), v);
-		return o;
+		return new AnonObject(v.copy());
+
+		//return o;
 	}
 
-	@:access(python.Boot) public static function anonToDict (o:{}):Dynamic
+
+	public static function anonToDict (o:{}):Dynamic
 	{
-		return if (python.Boot.isAnonObject(o))
+		return if (HxBuiltin.isinstance(o, AnonObject))
 		{
-			Syntax.field(o, "__dict__");
+			(Syntax.field(o, "__dict__"):Dict<String,Dynamic>).copy();
 		}
 		else null;
 

std/python/internal/ArrayImpl.hx

@@ -29,16 +29,16 @@ import python.internal.HxBuiltin;
 @:keep
 class ArrayImpl {
 
-	static inline function builtin():Dynamic return HxBuiltin.instance();
 
-	public static inline function get_length <T>(x:Array<T>):Int return Syntax.callField(builtin(), "len", x);
+
+	public static inline function get_length <T>(x:Array<T>):Int return Syntax.callField(HxBuiltin, "len", x);
 
 	public static inline function concat<T>( a1:Array<T>, a2 : Array<T>) : Array<T> {
 		return Syntax.binop(a1, "+", a2);
 	}
 
 	public static inline function copy<T>(x:Array<T>) : Array<T> {
-		return Syntax.field(builtin(), "list")(x);
+		return Syntax.field(HxBuiltin, "list")(x);
 	}
 
 	public static inline function iterator<T>(x:Array<T>) : Iterator<T> {
@@ -122,11 +122,11 @@ class ArrayImpl {
 	}
 
 	public static inline function map<S,T>(x:Array<T>, f : T -> S ) : Array<S> {
-		return Syntax.field(builtin(), "list")(Syntax.field(builtin(), "map")(f, x));
+		return Syntax.field(HxBuiltin, "list")(Syntax.field(HxBuiltin, "map")(f, x));
 	}
 
 	public static inline function filter<T>(x:Array<T>, f : T -> Bool ) : Array<T> {
-		return Syntax.field(builtin(), "list")(Syntax.field(builtin(), "filter")(f, x));
+		return Syntax.field(HxBuiltin, "list")(Syntax.field(HxBuiltin, "filter")(f, x));
 	}
 
 	public static inline function insert<T>(a:Array<T>, pos : Int, x : T ) : Void {

std/python/internal/HxBuiltin.hx

@@ -1,6 +1,37 @@
-
 package python.internal;
 
-@:pythonImport("builtins") extern class HxBuiltin {
-	public static inline function instance ():Dynamic return HxBuiltin;
+@:pythonImport("builtins") extern class HxBuiltin
+{
+	public static function bool(x:Dynamic):Bool;
+
+	public static function issubclass(x:Class<Dynamic>, from:Class<Dynamic>):Bool;
+	public static function callable(x:Dynamic):Bool;
+
+	public static function isinstance(obj:Dynamic, cl:Dynamic):Bool;
+
+	public static function hasattr(obj:Dynamic, attr:String):Bool;
+	public static function getattr(obj:Dynamic, attr:String):Dynamic;
+
+	public static function delattr(o:Dynamic, attr:String):Void;
+	public static function setattr(o:Dynamic, attr:String, val:Dynamic):Void;
+
+	public static function len(x:Dynamic):Int;
+	public static function int(x:Dynamic):Int;
+	public static function ord(s:String):Int;
+
+	public static function str(o:Dynamic):String;
+
+	public static function float(x:Dynamic):Float;
+
+	public static function list<T>(i:Dynamic):Array<T>;
+
+	public static function chr(c:Int):String;
+
+	@:overload(function (a1:Float, a2:Float, ?a3:Float, ?a4:Float, ?a5:Float, ?a6:Float, ?a7:Float, ?a8:Float, ?a9:Float):Float {})
+	public static function max(a1:Int, a2:Int, ?a3:Int, ?a4:Int, ?a5:Int, ?a6:Int, ?a7:Int, ?a8:Int, ?a9:Int):Int;
+
+	public static function round(f:Float):Int;
+
+	@:overload(function (a1:Float, a2:Float, ?a3:Float, ?a4:Float, ?a5:Float, ?a6:Float, ?a7:Float, ?a8:Float, ?a9:Float):Float {})
+	public static function min(a1:Int, a2:Int, ?a3:Int, ?a4:Int, ?a5:Int, ?a6:Int, ?a7:Int, ?a8:Int, ?a9:Int):Int;
 }

std/python/internal/Internal.hx

@@ -42,7 +42,7 @@ class Internal {
 	}
 
 	static function has (o:Expr, field:String):Expr {
-		return macro python.internal.HxBuiltin.instance().hasattr($o, $v{field});
+		return macro python.internal.HxBuiltin.hasattr($o, $v{field});
 	}
 
 	#end

std/python/internal/StringImpl.hx

@@ -3,20 +3,20 @@ package python.internal;
 import python.internal.Internal;
 import python.internal.HxBuiltin;
 
+
+
 @:keep
 @:native("HxString")
 class StringImpl {
 
-	static inline function builtin():Dynamic return HxBuiltin.instance();
-
 	public static function split (s:String, d:String) {
-		return if (d == "") Syntax.field(builtin(), "list")(s) else Syntax.callField(s, "split", d);
+		return if (d == "") Syntax.field(HxBuiltin, "list")(s) else Syntax.callField(s, "split", d);
 	}
 
 	public static function charCodeAt(s:String, index:Int) {
 		return
 			if (s == null || s.length == 0 || index < 0 || index >= s.length) null
-			else Syntax.callField(builtin(), "ord", Syntax.arrayAccess(s, index));
+			else Syntax.callField(HxBuiltin, "ord", Syntax.arrayAccess(s, index));
 	}
 
 	public static inline function charAt(s:String, index:Int) {
@@ -29,7 +29,7 @@ class StringImpl {
 		} else {
 
 			var i = Syntax.callField(s, "rfind", str, 0, startIndex+1);
-			var startLeft = i == -1 ? Syntax.callField(builtin(), "max", 0,startIndex+1-str.length) : i+1;
+			var startLeft = i == -1 ? Syntax.callField(HxBuiltin, "max", 0,startIndex+1-str.length) : i+1;
 			var check = Syntax.callField(s,"find", str, startLeft, s.length);
 			if (check > i && check <= startIndex) {
 				return check;
@@ -58,7 +58,7 @@ class StringImpl {
 	}
 
 	public static function get_length (s:String) {
-		return Syntax.field(builtin(), "len")(s);
+		return Syntax.field(HxBuiltin, "len")(s);
 	}
 
 	public static inline function fromCharCode( code : Int ) : String {
@@ -67,7 +67,7 @@ class StringImpl {
 		#else
 		var c = code;
 		return Syntax.callField('', "join",
-			Syntax.callField(builtin(), "map", Syntax.field(builtin(), "chr"), [c])); // TODO: check cast
+			Syntax.callField(HxBuiltin, "map", Syntax.field(HxBuiltin, "chr"), [c])); // TODO: check cast
 		#end
 	}
 

std/python/lib/Dict.hx

@@ -47,9 +47,7 @@ extern class Dict <K, V>
 	public function values ():DictView<V>;
 	public function items ():DictView<Tup2<K,V>>;
 
-	public static inline function fromObject (x:{}):Dict<String,Dynamic> {
-		return DictImpl.fromObject(x);
-	}
+
 	public inline function set (key:K, val:V):Void {
 		DictImpl.set(this, key, val);
 	}
@@ -67,13 +65,7 @@ extern class Dict <K, V>
 }
 
 class DictImpl {
-	public static inline function fromObject (x:{}) {
-		var d = new Dict();
-		for (f in Reflect.fields(x)) {
-			d.set(f, Reflect.field(x,f));
-		}
-		return d;
-	}
+
 	public static inline function hasKey <X>(d:Dict<X, Dynamic>, key:X) {
 		return Syntax.isIn(key, d);
 	}

tests/unit/TestPython.hx

@@ -248,9 +248,8 @@ class TestPython extends Test {
 			return a + b;
 		}
 
-
-		var res = x( python.lib.Dict.fromObject({ "a" : 1, "b" : 2}) );
-
+		var a = python.Lib.anonToDict({ "a" : 1, "b" : 2});
+		var res = x( a );
 
 		eq(3, res);