[python] get rid of HxBuiltin, clean up things here and there

std/python/Boot.hx

@@ -7,7 +7,7 @@ import python.internal.EnumImpl;
 import python.internal.HxOverrides;
 import python.internal.HxException;
 import python.internal.AnonObject;
-import python.internal.HxBuiltin;
+import python.lib.Builtin;
 import python.lib.Inspect;
 import python.lib.Set;
 
@@ -104,56 +104,28 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 		return Syntax.field(sep, "join")(Syntax.pythonCode("[{0}(x1,'') for x1 in {1}]", python.Boot.toString1, x));
 	}
 
-	inline static function isInstance(o:Dynamic, x:Dynamic):Bool {
-		return HxBuiltin.isinstance(o,x);
-	}
-
-	inline static function builtinStr(o:Dynamic):String {
-		return HxBuiltin.str(o);
-	}
-
-	inline static function builtinHasAttr(o:Dynamic, x:String):Bool {
-		return HxBuiltin.hasattr(o, x);
-	}
-
-	inline static function builtinGetAttr(o:Dynamic, x:String):Dynamic {
-		return HxBuiltin.getattr(o, x);
-	}
-
 	inline static function isPyBool(o:Dynamic):Bool {
-		return isInstance(o, HxBuiltin.bool);
+		return Builtin.isinstance(o, Builtin.bool);
 	}
 
 	inline static function isPyInt(o:Dynamic):Bool {
-		return isInstance(o, HxBuiltin.int);
+		return Builtin.isinstance(o, Builtin.int);
 	}
 
 	inline static function isPyFloat(o:Dynamic):Bool {
-		return isInstance(o, HxBuiltin.float);
-	}
-
-	inline static function builtinLen(o:Dynamic):Int {
-		return Syntax.callField(HxBuiltin, "len", o);
-	}
-
-	inline static function builtinInt(o:Dynamic):Int {
-		return Syntax.callField(HxBuiltin, "int", o);
-	}
-
-	inline static function builtinCallable(o:Dynamic):Bool {
-		return Syntax.callField(HxBuiltin, "callable", o);
+		return Builtin.isinstance(o, Builtin.float);
 	}
 
 	static inline function isClass(o:Dynamic) : Bool {
 		return o != null && (o == String || Inspect.isclass(o));
 	}
 
-	static function isAnonObject (o:Dynamic) {
-		return isInstance(o, AnonObject);
+	static inline function isAnonObject(o:Dynamic) {
+		return Builtin.isinstance(o, AnonObject);
 	}
 
 	private static function _add_dynamic(a:Dynamic,b:Dynamic):Dynamic {
-		if (isInstance(a, String) || isInstance(b, String)) {
+		if (Builtin.isinstance(a, String) || Builtin.isinstance(b, String)) {
 			return Syntax.binop(toString1(a,""), "+", toString1(b,""));
 		}
 		return Syntax.binop(a, "+", b);
@@ -176,18 +148,18 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 			if ((o:Bool)) return "true" else return "false";
 		}
 		if (isPyInt(o)) {
-			return builtinStr(o);
+			return Builtin.str(o);
 		}
 		// 1.0 should be printed as 1
 		if (isPyFloat(o)) {
 			try {
-				if ( (o:Float) == builtinInt(o)) {
-					return builtinStr(Math.round(o));
+				if ( (o:Float) == Builtin.int(o)) {
+					return Builtin.str(Math.round(o));
 				} else {
-					return builtinStr(o);
+					return Builtin.str(o);
 				}
 			} catch (e:Dynamic) {
-				return builtinStr(o);
+				return Builtin.str(o);
 			}
 		}
 
@@ -210,15 +182,14 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 		}
 
 		try {
-			if (builtinHasAttr(o, "toString")) {
+			if (Builtin.hasattr(o, "toString"))
 				return Syntax.callField(o, "toString");
-			}
 		} catch (e:Dynamic) {
 		}
 
 		if (Inspect.isfunction(o) || Inspect.ismethod(o)) return "<function>";
 
-		if (builtinHasAttr(o, "__class__"))
+		if (Builtin.hasattr(o, "__class__"))
 		{
 
 			if (isAnonObject(o))
@@ -244,11 +215,11 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 				}
 
 			}
-			if (isInstance(o, Enum)) {
+			if (Builtin.isinstance(o, Enum)) {
 
 				var o:EnumImpl = o;
 
-				var l = builtinLen(o.params);
+				var l = Builtin.len(o.params);
 				var hasParams = l > 0;
 				if (hasParams) {
 					var paramsStr = "";
@@ -288,25 +259,25 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 				return "#Array";
 			}
 
-			if (builtinCallable(o)) {
+			if (Builtin.callable(o)) {
 				return "function";
 			}
 			try {
-				if (builtinHasAttr(o, "__repr__")) {
+				if (Builtin.hasattr(o, "__repr__")) {
 					return Syntax.callField(o, "__repr__");
 				}
 			} catch (e:Dynamic) {}
 
-			if (builtinHasAttr(o, "__str__")) {
+			if (Builtin.hasattr(o, "__str__")) {
 				return Syntax.callField(o, "__str__", []);
 			}
 
-			if (builtinHasAttr(o, "__name__")) {
+			if (Builtin.hasattr(o, "__name__")) {
 				return Syntax.field(o, "__name__");
 			}
 			return "???";
 		} else {
-			return builtinStr(o);
+			return Builtin.str(o);
 		}
 	}
 
@@ -321,7 +292,7 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 				var fields:Array<String> = Internal.fieldFields(o);
 				return fields.copy();
 			}
-			if (isInstance(o, AnonObject)) {
+			if (isAnonObject(o)) {
 
 				var d = Syntax.field(o, "__dict__");
 				var keys = Syntax.callField(d, "keys");
@@ -330,7 +301,7 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 				Syntax.pythonCode("for k in keys:");
 				Syntax.pythonCode("	a.append(handler(k))");
 			}
-			else if (builtinHasAttr(o, "__dict__")) {
+			else if (Builtin.hasattr(o, "__dict__")) {
 				var a = [];
 				var d = Syntax.field(o, "__dict__");
 				var keys1  = Syntax.callField(d, "keys");
@@ -343,11 +314,11 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 	}
 
 	static inline function isString (o:Dynamic):Bool {
-		return isInstance(o, HxBuiltin.str);
+		return Builtin.isinstance(o, Builtin.str);
 	}
 
 	static inline function isArray (o:Dynamic):Bool {
-		return isInstance(o, HxBuiltin.list);
+		return Builtin.isinstance(o, Builtin.list);
 	}
 
 	static function field( o : Dynamic, field : String ) : Dynamic {
@@ -389,7 +360,7 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 
 
 		var field = handleKeywords(field);
-		return if (builtinHasAttr(o, field)) builtinGetAttr(o, field) else null;
+		return if (Builtin.hasattr(o, field)) Builtin.getattr(o, field) else null;
 	}
 
 
@@ -448,7 +419,7 @@ private class ClassRegistry extends python.lib.Dict<String, HxClassBase> {
 
 
 	static inline function unsafeFastCodeAt (s, index) {
-		return HxBuiltin.ord(python.Syntax.arrayAccess(s, index));
+		return Builtin.ord(python.Syntax.arrayAccess(s, index));
 	}
 
 	static inline function handleKeywords(name:String):String {

std/python/Lib.hx

@@ -1,7 +1,6 @@
 package python;
 
 import python.internal.AnonObject;
-import python.internal.HxBuiltin;
 import python.lib.Dict;
 import python.NativeStringTools;
 
@@ -31,7 +30,7 @@ class Lib {
 
 	public static function anonToDict (o:{}):Dict<String, Dynamic>
 	{
-		return if (HxBuiltin.isinstance(o, AnonObject))
+		return if (python.lib.Builtin.isinstance(o, AnonObject))
 		{
 			(Syntax.field(o, "__dict__"):Dict<String,Dynamic>).copy();
 		}

std/python/_std/Math.hx

@@ -1,8 +1,3 @@
-
-package;
-
-import python.lib.Builtin;
-
 /*
  * Copyright (C)2005-2012 Haxe Foundation
  *
@@ -24,6 +19,8 @@ import python.lib.Builtin;
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
+import python.lib.Builtin;
+
 /**
 	This class defines mathematical functions and constants.
 **/

std/python/_std/haxe/Resource.hx

@@ -28,8 +28,8 @@ import haxe.io.BytesData;
 
 	static var content : python.lib.Dict<String, BytesData> = untyped _hx_resources__();
 
-	public static function listNames() : Array<String> {
-		return python.internal.HxBuiltin.list(content.keys());
+	public static inline function listNames() : Array<String> {
+		return python.lib.Builtin.list(content.keys());
 	}
 
 	public static function getString( name : String ) : String {

std/python/internal/ArrayImpl.hx

@@ -23,22 +23,20 @@
 package python.internal;
 
 import python.lib.FuncTools;
-import python.internal.HxBuiltin;
+import python.lib.Builtin;
 
 @:allow(Array)
 @:keep
 class ArrayImpl {
 
+	public static inline function get_length <T>(x:Array<T>):Int return Builtin.len(x);
 
-
-	public static inline function get_length <T>(x:Array<T>):Int return HxBuiltin.len(x);
-
-	public static inline function concat<T>( a1:Array<T>, a2 : Array<T>) : Array<T> {
+	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(HxBuiltin, "list")(x);
+		return Builtin.list(x);
 	}
 
 	public static inline function iterator<T>(x:Array<T>) : Iterator<T> {
@@ -123,12 +121,12 @@ class ArrayImpl {
 		return res;
 	}
 
-	public static inline function map<S,T>(x:Array<T>, f : T -> S ) : Array<S> {
-		return Syntax.field(HxBuiltin, "list")(Syntax.field(HxBuiltin, "map")(f, x));
+	public static inline function map<S,T>(x:Array<T>, f : T -> S) : Array<S> {
+		return Builtin.list(Builtin.map(f, cast x));
 	}
 
-	public static inline function filter<T>(x:Array<T>, f : T -> Bool ) : Array<T> {
-		return Syntax.field(HxBuiltin, "list")(Syntax.field(HxBuiltin, "filter")(f, x));
+	public static inline function filter<T>(x:Array<T>, f : T -> Bool) : Array<T> {
+		return Builtin.list(Builtin.filter(f, cast x));
 	}
 
 	public static inline function insert<T>(a:Array<T>, pos : Int, x : T ) : Void {

std/python/internal/HxBuiltin.hx

@@ -1,38 +0,0 @@
-package python.internal;
-
-@: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 map (a:Dynamic, b:Dynamic):Dynamic;
-	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

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

std/python/internal/StringImpl.hx

@@ -1,20 +1,20 @@
 package python.internal;
 
 import python.internal.Internal;
-import python.internal.HxBuiltin;
+import python.lib.Builtin;
 
 @:keep
 @:native("HxString")
 class StringImpl {
 
 	public static inline function split (s:String, d:String) {
-		return if (d == "") Syntax.field(HxBuiltin, "list")(s) else Syntax.callField(s, "split", d);
+		return if (d == "") Builtin.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(HxBuiltin, "ord", Syntax.arrayAccess(s, index));
+			else Builtin.ord(Syntax.arrayAccess(s, index));
 	}
 
 	public static inline function charAt(s:String, index:Int) {
@@ -27,7 +27,7 @@ class StringImpl {
 		} else {
 
 			var i = Syntax.callField(s, "rfind", str, 0, startIndex+1);
-			var startLeft = i == -1 ? Syntax.callField(HxBuiltin, "max", 0,startIndex+1-str.length) : i+1;
+			var startLeft = i == -1 ? Builtin.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;
@@ -56,16 +56,14 @@ class StringImpl {
 	}
 
 	public static inline function get_length (s:String) {
-		return Syntax.field(HxBuiltin, "len")(s);
+		return Builtin.len(s);
 	}
 
 	public static inline function fromCharCode( code : Int ) : String {
 		#if doc_gen
 		return "";
 		#else
-		var c = code;
-		return Syntax.callField('', "join",
-			Syntax.callField(HxBuiltin, "map", Syntax.field(HxBuiltin, "chr"), [c])); // TODO: check cast
+		return Syntax.callField('', "join", Builtin.map(Builtin.chr, cast [code])); // TODO: check cast
 		#end
 	}
 

std/python/lib/Builtin.hx

@@ -25,7 +25,7 @@ extern class Builtin {
 
 
 
-	@:overload(function (obj:Dynamic, f:Tuple<Dynamic>):Bool {})
+	@:overload(function(obj:Dynamic, f:Tuple<Dynamic>):Bool {})
 	public static function isinstance(obj:Dynamic, cl:Dynamic):Bool;
 
 	public static function hasattr(obj:Dynamic, attr:String):Bool;
@@ -51,9 +51,7 @@ extern class Builtin {
 	@:overload(function (x:Dynamic, base:Int):Int {})
 	public static function int(x:Dynamic):Int;
 	public static function ord(s:String):Int;
-	public static inline function str(o:Dynamic):String {
-		return python.Syntax.field(Builtin, "str")(o);
-	}
+	public static function str(o:Dynamic):String;
 	//public static function eval():Void;
 
 	//public static function pow():Void;
@@ -89,8 +87,9 @@ extern class Builtin {
 	public static function float(x:Dynamic):Float;
 
 	@:overload(function <T>(f:Array<T>):Array<T> {})
+	@:overload(function <T>(f:Tuple<T>):Array<T> {})
+	@:overload(function <T>(f:Dict.DictView<T>):Array<T> {})
 	@:overload(function (f:String):Array<String> {})
-	@:overload(function <G>(f:Tuple<G>):Array<G> {})
 	public static function list<T>(i:NativeIterable<T>):Array<T>;
 
 	@:overload(function <A>(f:A->Bool, i:NativeIterable<A>):NativeIterator<A> {})
@@ -114,8 +113,8 @@ extern class Builtin {
 	//public static function xrange():Void;
 	//public static function cmp():Void;
 	//public static function globals():Void;
-	@: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;
+	@:overload(function (a1:Float, a2:Float, rest:haxe.Rest<Float>):Float {})
+	public static function max(a1:Int, a2:Int, rest:haxe.Rest<Int>):Int;
 	//public static function reversed():Void;
 	//public static function zip():Void;
 	//public static function compile():Void;
@@ -125,8 +124,8 @@ extern class Builtin {
 	//public static function __import__():Void;
 	//public static function complex():Void;
 	//public static function hash():Void;
-	@: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;
+	@:overload(function (a1:Float, a2:Float, rest:haxe.Rest<Float>):Float {})
+	public static function min(a1:Int, a2:Int, rest:haxe.Rest<Int>):Int;
 	//public static function set():Void;
 	//public static function apply():Void;
 	public static function delattr(o:Dynamic, attr:String):Void;