[java] many fixes for the unit tests

codegen.ml

@@ -501,6 +501,7 @@ let add_field_inits com c =
 				tf_expr = mk (TBlock el) com.basic.tvoid c.cl_pos;
 			}) ct c.cl_pos in
 			let ctor = mk_field "new" ct c.cl_pos in
+      ctor.cf_kind <- Method MethNormal;
 			c.cl_constructor <- Some { ctor with cf_expr = Some ce };
 		| Some cf ->
 			match cf.cf_expr with

gencommon.ml

@@ -1816,10 +1816,24 @@ struct
                       | _ -> [tf.tf_expr]
                     in
                     
-                    let block = match block with
-                      | ({ eexpr = TCall({ eexpr = TConst(TSuper) }, _) } as hd) :: tl ->
-                        (hd :: funs) @ tl
-                      | _ -> funs @ block
+                    let found = ref false in
+                    let rec add_fn block acc =
+                      match block with
+                        | ({ eexpr = TCall({ eexpr = TConst(TSuper) }, _) } as hd) :: tl ->
+                          found := true;
+                          (List.rev acc) @ ((hd :: funs) @ tl)
+                        | ({ eexpr = TBlock bl } as hd) :: tl ->
+                          add_fn tl ( ({ hd with eexpr = TBlock (add_fn bl []) }) :: acc )
+                        | hd :: tl ->
+                          add_fn tl ( hd :: acc )
+                        | [] -> List.rev acc
+                    in
+                    
+                    let block = add_fn block [] in
+                    let block = if !found then 
+                      block
+                    else
+                      funs @ block
                     in
                     
                     { e with eexpr = TFunction({
@@ -4449,7 +4463,18 @@ struct
                 let args, ret = get_args e1.etype in
                 let args, ret = List.map (fun (n,o,t) -> (n,o,gen.greal_type t)) args, gen.greal_type ret in
                 (try
-                  handle_cast gen { ecall with eexpr = TCall({ e1 with eexpr = TField(ef, f) }, List.map2 (fun param (_,_,t) -> handle_cast gen param (gen.greal_type t) (gen.greal_type param.etype)) elist args) } (gen.greal_type ecall.etype) (gen.greal_type ret)
+                  handle_cast gen 
+                  { ecall with 
+                    eexpr = TCall(
+                      { e1 with eexpr = TField(ef, f) }, 
+                      List.map2 (fun param (_,_,t) -> 
+                        match param.eexpr with
+                          | TConst TNull -> (* when we have overloads and null const, we must force a cast otherwise we may get ambiguous call errors *)
+                            mk_cast (gen.greal_type t) param
+                          | _ ->
+                            handle_cast gen param (gen.greal_type t) (gen.greal_type param.etype)) elist args
+                    ) 
+                  } (gen.greal_type ecall.etype) (gen.greal_type ret)
                 with | Invalid_argument("List.map2") ->
                   gen.gcon.warning "This expression may be invalid" ecall.epos;
                   handle_cast gen ({ ecall with eexpr = TCall({ e1 with eexpr = TField(ef, f) }, elist )  }) (gen.greal_type ecall.etype) (gen.greal_type ret)
@@ -5993,11 +6018,15 @@ struct
       match objdecl with
         | [] -> acc,acc_f
         | ( (name,expr) as hd ) :: tl ->
-          match follow (gen.greal_type expr.etype) with
-            | TInst( { cl_path = [], "Float" }, [] )
-            | TInst( { cl_path = [], "Int" }, [] ) ->
-              loop tl acc (hd :: acc_f)
-            | _ -> loop tl (hd :: acc) acc_f
+          match follow expr.etype with
+            | TInst ( { cl_path = ["haxe"], "Int64" }, [] ) ->
+              loop tl (hd :: acc) acc_f
+            | _ ->
+              match follow (gen.greal_type expr.etype) with
+                | TInst( { cl_path = [], "Float" }, [] )
+                | TInst( { cl_path = [], "Int" }, [] ) ->
+                  loop tl acc (hd :: acc_f)
+                | _ -> loop tl (hd :: acc) acc_f
     in
     
     let may_hash_field s =

gencs.ml

@@ -523,7 +523,7 @@ let configure gen =
       | TInst ({ cl_path = ([],"Float") },[])
       | TInst ({ cl_path = ([],"Int") },[]) 
       | TType ({ t_path = [],"UInt" },[])
-      | TType ({ t_path = [],"Int64" },[])
+      | TType ({ t_path = ["haxe";"_Int64"], "NativeInt64" },[])
       | TType ({ t_path = ["cs"],"UInt64" },[])
       | TType ({ t_path = ["cs"],"UInt8" },[])
       | TType ({ t_path = ["cs"],"Int8" },[])
@@ -542,7 +542,7 @@ let configure gen =
   
   let ifaces = Hashtbl.create 1 in
   
-  let ti64 = match ( get_type gen ([], "Int64") ) with | TTypeDecl t -> TType(t,[]) | _ -> assert false in
+  let ti64 = match ( get_type gen (["haxe";"_Int64"], "NativeInt64") ) with | TTypeDecl t -> TType(t,[]) | _ -> assert false in
   
   let ttype = get_cl ( get_type gen (["System"], "Type") ) in
   
@@ -631,7 +631,7 @@ let configure gen =
       | TInst ({ cl_path = ([],"Float") },[]) -> "double"
       | TInst ({ cl_path = ([],"Int") },[]) -> "int"
       | TType ({ t_path = [],"UInt" },[]) -> "uint"
-      | TType ({ t_path = [],"Int64" },[]) -> "long"
+      | TType ({ t_path = ["haxe";"_Int64"], "NativeInt64" },[]) -> "long"
       | TType ({ t_path = ["cs"],"UInt64" },[]) -> "ulong"
       | TType ({ t_path = ["cs"],"UInt8" },[]) -> "byte"
       | TType ({ t_path = ["cs"],"Int8" },[]) -> "sbyte"
@@ -729,7 +729,7 @@ let configure gen =
             | TInt i32 -> 
               write w (Int32.to_string i32);
               (*match real_type e.etype with
-                | TType( { t_path = ([], "Int64") }, [] ) -> write w "L";
+                | TType( { t_path = (["haxe";"_Int64"], "NativeInt64") }, [] ) -> write w "L";
                 | _ -> ()
               *)
             | TFloat s -> 

genjava.ml

@@ -630,7 +630,7 @@ let configure gen =
   
   (*let string_ref = get_cl ( get_type gen (["haxe";"lang"], "StringRefl")) in*)
   
-  let ti64 = match ( get_type gen ([], "Int64") ) with | TTypeDecl t -> TType(t,[]) | _ -> assert false in
+  let ti64 = match ( get_type gen (["haxe";"_Int64"], "NativeInt64") ) with | TTypeDecl t -> TType(t,[]) | _ -> assert false in
   
   let has_tdynamic params =
     List.exists (fun e -> match gen.greal_type e with | TDynamic _ -> true | _ -> false) params
@@ -654,7 +654,7 @@ let configure gen =
                   | TInst ({ cl_path = ([],"Float") },[])
                   | TInst ({ cl_path = ["haxe"],"Int32" },[])
                   | TInst ({ cl_path = ([],"Int") },[])
-                  | TType ({ t_path = [],"Int64" },[])
+                  | TType ({ t_path = ["haxe";"_Int64"], "NativeInt64" },[])
                   | TType ({ t_path = ["haxe"],"Int64" },[])
                   | TType ({ t_path = ["java"],"Int8" },[])
                   | TType ({ t_path = ["java"],"Int16" },[])
@@ -691,7 +691,7 @@ let configure gen =
       | TInst ({ cl_path = ([],"Int") },[]) 
       | TInst( { cl_path = (["haxe"], "Int32") }, [] )
       | TInst( { cl_path = (["haxe"], "Int64") }, [] )
-      | TType ({ t_path = [],"Int64" },[])
+      | TType ({ t_path = ["haxe";"_Int64"], "NativeInt64" },[])
       | TType ({ t_path = ["java"],"Int8" },[])
       | TType ({ t_path = ["java"],"Int16" },[])
       | TType ({ t_path = ["java"],"Char16" },[])
@@ -747,7 +747,7 @@ let configure gen =
       | TEnum ({ e_path = ([], "Void") }, []) -> "java.lang.Object"
       | TInst ({ cl_path = ([],"Float") },[]) -> "double"
       | TInst ({ cl_path = ([],"Int") },[]) -> "int"
-      | TType ({ t_path = [],"Int64" },[]) -> "long"
+      | TType ({ t_path = ["haxe";"_Int64"], "NativeInt64" },[]) -> "long"
       | TType ({ t_path = ["java"],"Int8" },[]) -> "byte"
       | TType ({ t_path = ["java"],"Int16" },[]) -> "short"
       | TType ({ t_path = ["java"],"Char16" },[]) -> "char"
@@ -784,7 +784,7 @@ let configure gen =
       | TEnum ({ e_path = ([], "Bool") }, []) -> "java.lang.Boolean"
       | TInst ({ cl_path = ([],"Float") },[]) -> "java.lang.Double"
       | TInst ({ cl_path = ([],"Int") },[]) -> "java.lang.Integer"
-      | TType ({ t_path = [],"Int64" },[]) -> "java.lang.Long"
+      | TType ({ t_path = ["haxe";"_Int64"], "NativeInt64" },[]) -> "java.lang.Long"
       | TInst ({ cl_path = ["haxe"],"Int64" },[]) -> "java.lang.Long"
       | TInst ({ cl_path = ["haxe"],"Int32" },[]) -> "java.lang.Integer"
       | TType ({ t_path = ["java"],"Int8" },[]) -> "java.lang.Byte"
@@ -872,7 +872,7 @@ let configure gen =
             | TInt i32 -> 
               print w "%ld" i32;
               (match real_type e.etype with
-                | TType( { t_path = ([], "Int64") }, [] ) -> write w "L";
+                | TType( { t_path = (["haxe";"_Int64"], "NativeInt64") }, [] ) -> write w "L";
                 | _ -> ()
               )
             | TFloat s -> 
@@ -887,7 +887,7 @@ let configure gen =
             | TBool b -> write w (if b then "true" else "false")
             | TNull -> 
               (match real_type e.etype with
-                | TType( { t_path = ([], "Int64") }, [] )
+                | TType( { t_path = (["haxe";"_Int64"], "NativeInt64") }, [] )
                 | TInst( { cl_path = (["haxe"], "Int64") }, [] ) -> write w "0L"
                 | TInst( { cl_path = (["haxe"], "Int32") }, [] )
                 | TInst({ cl_path = ([], "Int") },[]) -> expr_s w ({ e with eexpr = TConst(TInt Int32.zero) })
@@ -1623,7 +1623,11 @@ let configure gen =
       let is_null e = match e.eexpr with | TConst(TNull) | TLocal({ v_name = "__undefined__" }) -> true | _ -> false in
       
       if is_null e1 || is_null e2 then 
-        { e1 with eexpr = TBinop(Ast.OpEq, e1, e2); etype = basic.tbool }
+        match e1.eexpr, e2.eexpr with
+          | TConst c1, TConst c2 ->
+            { e1 with eexpr = TConst(TBool (c1 = c2)); etype = basic.tbool }
+          | _ ->
+            { e1 with eexpr = TBinop(Ast.OpEq, e1, e2); etype = basic.tbool }
       else begin
         let is_ref = match follow e1.etype, follow e2.etype with
           | TDynamic _, _

std/StdTypes.hx

@@ -50,7 +50,6 @@ typedef UInt = Int
 
 #if (java || cs)
 typedef Single = Float;
-typedef Int64 = Int;
 #end
 
 /**

std/cs/NativeArray.hx

@@ -6,7 +6,7 @@ extern class NativeArray<T> extends system.Array, implements ArrayAccess<T>
 	
 	public function new(len:Int):Void;
 	
-	@:overload(function(arr:system.Array, destIndex:Int64):Void {} )
+	@:overload(function(arr:system.Array, destIndex:haxe.Int64):Void {} )
 	public function CopyTo(arr:system.Array, destIndex:Int):Void;
 	
 	static function Reverse(arr:system.Array):Void;

std/cs/_std/IntHash.hx

@@ -102,6 +102,7 @@ import cs.NativeArray;
 		} else if (flagIsDel(flags, x)) {
 			_keys[x] = key;
 			vals[x] = value;
+			setIsBothFalse(flags, x);
 			size++;
 		} else {
 			assert(_keys[x] == key);

std/cs/_std/Std.hx

@@ -52,13 +52,18 @@ import cs.internal.Exceptions;
 		var ret = 0;
 		var base = 10;
 		var i = -1;
-		if (StringTools.startsWith(x, "0x"))
+		var len = x.length;
+		
+		if (StringTools.startsWith(x, "0") && len > 2)
 		{
-			i = 1;
-			base = 16;
+			var c:Int = cast untyped x[1];
+			if (c == 'x'.code || c == 'X'.code)
+			{
+				i = 1;
+				base = 16;
+			}
 		}
 		
-		var len = x.length;
 		var foundAny = false;
 		var isNeg = false;
 		while (++i < len)

std/cs/_std/haxe/Int64.hx

@@ -23,128 +23,130 @@
  * DAMAGE.
  */
 package haxe;
-
-private typedef NativeInt64 = Int64;
+using haxe.Int64;
+private typedef NativeInt64 = Int;
 
 @:nativegen class Int64 
 {
-	public static inline function make( high : Int32, low : Int32 ) : Int64 
+	@:extern private static inline function asNative(i:haxe.Int64):NativeInt64 return untyped i
+	@:extern private static inline function ofNative(i:NativeInt64):haxe.Int64 return untyped i
+	@:extern private static inline function mkNative(i:Dynamic):NativeInt64 return i
+	
+	public static inline function make( high : Int32, low : Int32 ) : haxe.Int64 
 	{
-		return (cast(high, NativeInt64) << 32 ) | (cast(low, NativeInt64));
+		return ((cast(high, NativeInt64) << 32 ) | (cast(low, NativeInt64))).ofNative();
 	}
 
-	public static inline function ofInt( x : Int ) : Int64 {
+	public static inline function ofInt( x : Int ) : haxe.Int64 {
 		return cast x;
 	}
 
-	public static inline function ofInt32( x : Int32 ) : Int64 {
+	public static inline function ofInt32( x : Int32 ) : haxe.Int64 {
 		return cast x;
 	}
 
-	public static inline function toInt( x : Int64 ) : Int 
+	public static inline function toInt( x : haxe.Int64 ) : Int 
 	{
 		return cast x;
 	}
 
-	public static inline function getLow( x : Int64 ) : Int32 
+	public static inline function getLow( x : haxe.Int64 ) : Int32 
 	{
-		return cast x;
+		return cast (x.asNative() & 0xFFFFFFFF.mkNative());
 	}
 
-	public static inline function getHigh( x : Int64 ) : Int32 
+	public static inline function getHigh( x : haxe.Int64 ) : Int32 
 	{
-		return cast (cast(x,NativeInt64) >>> 32, Int32);
+		return cast(cast(x,NativeInt64) >>> 32, Int32);
 	}
 
-	public static inline function add( a : Int64, b : Int64 ) : Int64 
+	public static inline function add( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) + cast(b, NativeInt64);
+		return (a.asNative() + b.asNative()).ofNative();
 	}
 
-	public static inline function sub( a : Int64, b : Int64 ) : Int64 
+	public static inline function sub( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) - cast(b, NativeInt64);
+		return (a.asNative() - b.asNative()).ofNative();
 	}
 
-	public static inline function mul( a : Int64, b : Int64 ) : Int64 {
-		return cast(a, NativeInt64) * cast(b, NativeInt64);
+	public static inline function mul( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 {
+		return (a.asNative() * b.asNative()).ofNative();
 	}
 
-	static function divMod( modulus : Int64, divisor : Int64 ) 
+	static function divMod( modulus : haxe.Int64, divisor : haxe.Int64 ) 
 	{
-		var q:NativeInt64 = cast (cast(modulus, NativeInt64) / cast(divisor, NativeInt64));
-		var m:NativeInt64 = cast(modulus, NativeInt64) % cast(divisor, NativeInt64);
+		var q:Int64 = (modulus.asNative() / divisor.asNative()).mkNative().ofNative();
+		var m:Int64 = (modulus.asNative() % divisor.asNative()).mkNative().ofNative();
 		return { quotient : q, modulus : m };
 	}
 
-	public static inline function div( a : Int64, b : Int64 ) : Int64 {
-		return cast (cast(a, NativeInt64) / cast(b, NativeInt64));
+	public static inline function div( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 {
+		return (a.asNative() / b.asNative()).mkNative().ofNative();
 	}
 
-	public static inline function mod( a : Int64, b : Int64 ) : Int64 {
-		return cast(a, NativeInt64) % cast(b, NativeInt64);
+	public static inline function mod( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 {
+		return (a.asNative() % b.asNative()).mkNative().ofNative();
 	}
 
-	public static inline function shl( a : Int64, b : Int ) : Int64 {
-		return cast(a, NativeInt64) << b;
+	public static inline function shl( a : haxe.Int64, b : Int ) : haxe.Int64 {
+		return (a.asNative() << b).ofNative();
 	}
 
-	public static inline function shr( a : Int64, b : Int ) : Int64 {
-		return cast(a, NativeInt64) >> b;
+	public static inline function shr( a : haxe.Int64, b : Int ) : haxe.Int64 {
+		return (a.asNative() >> b).ofNative();
 	}
 
-	public static inline function ushr( a : Int64, b : Int ) : Int64 {
-		return cast(a, NativeInt64) >>> b;
+	public static inline function ushr( a : haxe.Int64, b : Int ) : haxe.Int64 {
+		return (a.asNative() >>> b).ofNative();
 	}
 
-	public static inline function and( a : Int64, b : Int64 ) : Int64 
+	public static inline function and( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) & cast(b, NativeInt64);
+		return (a.asNative() & b.asNative()).ofNative();
 	}
 
-	public static inline function or( a : Int64, b : Int64 ) : Int64 
+	public static inline function or( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) | cast(b, NativeInt64);
+		return (a.asNative() | b.asNative()).ofNative();
 	}
 
-	public static inline function xor( a : Int64, b : Int64 ) : Int64 
+	public static inline function xor( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) ^ cast(b, NativeInt64);
+		return (a.asNative() ^ b.asNative()).ofNative();
 	}
 
-	public static inline function neg( a : Int64 ) : Int64 
+	public static inline function neg( a : haxe.Int64 ) : haxe.Int64 
 	{
-		return -cast(a, NativeInt64);
+		return (~a.asNative()).ofNative();
 	}
 
-	public static inline function isNeg( a : Int64 ) : Bool 
+	public static inline function isNeg( a : haxe.Int64 ) : Bool 
 	{
-		return cast(a, NativeInt64) < cast(0, NativeInt64);
+		return (a.asNative() < 0.mkNative());
 	}
 
-	public static inline function isZero( a : Int64 ) : Bool 
+	public static inline function isZero( a : haxe.Int64 ) : Bool 
 	{
-		return cast(a, NativeInt64) == cast(0, NativeInt64);
+		return (a.asNative() == 0.mkNative());
 	}
 
-	public static inline function compare( a : Int64, b : Int64 ) : Int 
+	public static inline function compare( a : haxe.Int64, b : haxe.Int64 ) : Int 
 	{
-		return cast(cast(a, NativeInt64) - cast(b, NativeInt64), Int);
+		return cast (a.asNative() - b.asNative());
 	}
 
 	/**
 		Compare two Int64 in unsigned mode.
 	**/
-	public static function ucompare( a : Int64, b : Int64 ) : Int 
+	public static function ucompare( a : haxe.Int64, b : haxe.Int64 ) : Int 
 	{
-		var a:NativeInt64 = cast a;
-		var b:NativeInt64 = cast b;
-		if (a < cast(0, NativeInt64))
-			return (b < cast(0, NativeInt64)) ? compare(~a, ~b) : 1;
-		return (b < cast(0, NativeInt64)) ? -1 : compare(a, b);
+		if (a.asNative() < 0.mkNative())
+			return (b.asNative() < 0.mkNative()) ? compare( (~a.asNative()).ofNative(), (~b.asNative()).ofNative()) : 1;
+		return (b.asNative() < 0.mkNative()) ? -1 : compare(a, b);
 	}
 
-	public static inline function toStr( a : Int64 ) : String {
+	public static inline function toStr( a : haxe.Int64 ) : String {
 		return a + "";
 	}
 }

std/haxe/Resource.hx

@@ -36,6 +36,13 @@ class Resource {
 	}
 
 	public static function getString( name : String ) : String {
+		#if java
+		var stream = java.Lib.toNativeType(Resource).getResourceAsStream(name);
+		if (stream == null)
+			return null;
+		var stream = new java.io.NativeInput(stream);
+		return stream.readAll().toString();
+		#else
 		for( x in content )
 			if( x.name == name ) {
 				#if neko
@@ -47,9 +54,17 @@ class Resource {
 				#end
 			}
 		return null;
+		#end
 	}
 
 	public static function getBytes( name : String ) : haxe.io.Bytes {
+		#if java
+		var stream = java.Lib.toNativeType(Resource).getResourceAsStream(name);
+		if (stream == null)
+			return null;
+		var stream = new java.io.NativeInput(stream);
+		return stream.readAll();
+		#else
 		for( x in content )
 			if( x.name == name ) {
 				#if neko
@@ -60,6 +75,7 @@ class Resource {
 				#end
 			}
 		return null;
+		#end
 	}
 
 	static function __init__() {
@@ -70,6 +86,8 @@ class Resource {
 		content = null;
 		#elseif as3
 		null;
+		#elseif java
+		//do nothing
 		#else
 		content = untyped __resources__();
 		#end

std/java/Lib.hx

@@ -1,5 +1,4 @@
 package java;
-import java.lang.Class;
 
 //we cannot use the java package for custom classes, so we're redefining it as "haxe.java.Lib"
 @:native('haxe.java.Lib') class Lib 
@@ -18,8 +17,8 @@ import java.lang.Class;
 	
 	public static function toNativeType<T>(cl:Class<T>):java.lang.Class<T>
 	{
-		return untyped cl.nativeType();
-	}
+		return untyped cl;
+	}	
 	
 	@:functionBody('
 		return (java.lang.Class<T>) obj.getClass();

std/java/_std/IntHash.hx

@@ -102,6 +102,7 @@ import java.NativeArray;
 		} else if (flagIsDel(flags, x)) {
 			_keys[x] = key;
 			vals[x] = value;
+			setIsBothFalse(flags, x);
 			size++;
 		} else {
 			assert(_keys[x] == key);

std/java/_std/Std.hx

@@ -64,17 +64,22 @@ import java.internal.Exceptions;
 		
 		int ret = 0;
 		int base = 10;
+		int i = 0;
+		int len = x.length();
 		
-		if (x.startsWith("0x"))
+		if (x.startsWith("0") && len > 2)
 		{
-			x = x.substring(2);
-			base = 16;
+			char c = x.charAt(1);
+			if (c == \'x\' || c == \'X\')
+			{
+				i = 2;
+				base = 16;
+			}
 		}
 		
-		int len = x.length();
 		boolean foundAny = false;
 		boolean isNeg = false;
-		for (int i = 0; i < len; i++)
+		for (; i < len; i++)
 		{
 			char c = x.charAt(i);
 			if (!foundAny) 

std/java/_std/haxe/Int64.hx

@@ -23,128 +23,130 @@
  * DAMAGE.
  */
 package haxe;
-
-private typedef NativeInt64 = Int64;
+using haxe.Int64;
+private typedef NativeInt64 = Int;
 
 @:nativegen class Int64 
 {
-	public static inline function make( high : Int32, low : Int32 ) : Int64 
+	@:extern private static inline function asNative(i:haxe.Int64):NativeInt64 return untyped i
+	@:extern private static inline function ofNative(i:NativeInt64):haxe.Int64 return untyped i
+	@:extern private static inline function mkNative(i:Dynamic):NativeInt64 return i
+	
+	public static inline function make( high : Int32, low : Int32 ) : haxe.Int64 
 	{
-		return (cast(high, NativeInt64) << 32 ) | (cast(low, NativeInt64));
+		return ((cast(high, NativeInt64) << 32 ) | (cast(low, NativeInt64))).ofNative();
 	}
 
-	public static inline function ofInt( x : Int ) : Int64 {
+	public static inline function ofInt( x : Int ) : haxe.Int64 {
 		return cast x;
 	}
 
-	public static inline function ofInt32( x : Int32 ) : Int64 {
+	public static inline function ofInt32( x : Int32 ) : haxe.Int64 {
 		return cast x;
 	}
 
-	public static inline function toInt( x : Int64 ) : Int 
+	public static inline function toInt( x : haxe.Int64 ) : Int 
 	{
 		return cast x;
 	}
 
-	public static inline function getLow( x : Int64 ) : Int32 
+	public static inline function getLow( x : haxe.Int64 ) : Int32 
 	{
-		return cast x;
+		return cast (x.asNative() & 0xFFFFFFFF.mkNative());
 	}
 
-	public static inline function getHigh( x : Int64 ) : Int32 
+	public static inline function getHigh( x : haxe.Int64 ) : Int32 
 	{
-		return cast (cast(x,NativeInt64) >>> 32, Int32);
+		return cast(cast(x,NativeInt64) >>> 32, Int32);
 	}
 
-	public static inline function add( a : Int64, b : Int64 ) : Int64 
+	public static inline function add( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) + cast(b, NativeInt64);
+		return (a.asNative() + b.asNative()).ofNative();
 	}
 
-	public static inline function sub( a : Int64, b : Int64 ) : Int64 
+	public static inline function sub( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) - cast(b, NativeInt64);
+		return (a.asNative() - b.asNative()).ofNative();
 	}
 
-	public static inline function mul( a : Int64, b : Int64 ) : Int64 {
-		return cast(a, NativeInt64) * cast(b, NativeInt64);
+	public static inline function mul( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 {
+		return (a.asNative() * b.asNative()).ofNative();
 	}
 
-	static function divMod( modulus : Int64, divisor : Int64 ) 
+	static function divMod( modulus : haxe.Int64, divisor : haxe.Int64 ) 
 	{
-		var q:NativeInt64 = cast (cast(modulus, NativeInt64) / cast(divisor, NativeInt64));
-		var m:NativeInt64 = cast(modulus, NativeInt64) % cast(divisor, NativeInt64);
+		var q:Int64 = (modulus.asNative() / divisor.asNative()).mkNative().ofNative();
+		var m:Int64 = (modulus.asNative() % divisor.asNative()).mkNative().ofNative();
 		return { quotient : q, modulus : m };
 	}
 
-	public static inline function div( a : Int64, b : Int64 ) : Int64 {
-		return cast (cast(a, NativeInt64) / cast(b, NativeInt64));
+	public static inline function div( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 {
+		return (a.asNative() / b.asNative()).mkNative().ofNative();
 	}
 
-	public static inline function mod( a : Int64, b : Int64 ) : Int64 {
-		return cast(a, NativeInt64) % cast(b, NativeInt64);
+	public static inline function mod( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 {
+		return (a.asNative() % b.asNative()).mkNative().ofNative();
 	}
 
-	public static inline function shl( a : Int64, b : Int ) : Int64 {
-		return cast(a, NativeInt64) << cast(b, NativeInt64);
+	public static inline function shl( a : haxe.Int64, b : Int ) : haxe.Int64 {
+		return (a.asNative() << b).ofNative();
 	}
 
-	public static inline function shr( a : Int64, b : Int ) : Int64 {
-		return cast(a, NativeInt64) >> cast(b, NativeInt64);
+	public static inline function shr( a : haxe.Int64, b : Int ) : haxe.Int64 {
+		return (a.asNative() >> b).ofNative();
 	}
 
-	public static inline function ushr( a : Int64, b : Int ) : Int64 {
-		return cast(a, NativeInt64) >>> b;
+	public static inline function ushr( a : haxe.Int64, b : Int ) : haxe.Int64 {
+		return (a.asNative() >>> b).ofNative();
 	}
 
-	public static inline function and( a : Int64, b : Int64 ) : Int64 
+	public static inline function and( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) & cast(b, NativeInt64);
+		return (a.asNative() & b.asNative()).ofNative();
 	}
 
-	public static inline function or( a : Int64, b : Int64 ) : Int64 
+	public static inline function or( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) | cast(b, NativeInt64);
+		return (a.asNative() | b.asNative()).ofNative();
 	}
 
-	public static inline function xor( a : Int64, b : Int64 ) : Int64 
+	public static inline function xor( a : haxe.Int64, b : haxe.Int64 ) : haxe.Int64 
 	{
-		return cast(a, NativeInt64) ^ cast(b, NativeInt64);
+		return (a.asNative() ^ b.asNative()).ofNative();
 	}
 
-	public static inline function neg( a : Int64 ) : Int64 
+	public static inline function neg( a : haxe.Int64 ) : haxe.Int64 
 	{
-		return -cast(a, NativeInt64);
+		return (~a.asNative()).ofNative();
 	}
 
-	public static inline function isNeg( a : Int64 ) : Bool 
+	public static inline function isNeg( a : haxe.Int64 ) : Bool 
 	{
-		return cast(a, NativeInt64) < cast(0, NativeInt64);
+		return (a.asNative() < 0.mkNative());
 	}
 
-	public static inline function isZero( a : Int64 ) : Bool 
+	public static inline function isZero( a : haxe.Int64 ) : Bool 
 	{
-		return cast(a, NativeInt64) == cast(0, NativeInt64);
+		return (a.asNative() == 0.mkNative());
 	}
 
-	public static inline function compare( a : Int64, b : Int64 ) : Int 
+	public static inline function compare( a : haxe.Int64, b : haxe.Int64 ) : Int 
 	{
-		return cast(cast(a, NativeInt64) - cast(b, NativeInt64), Int);
+		return cast (a.asNative() - b.asNative());
 	}
 
 	/**
 		Compare two Int64 in unsigned mode.
 	**/
-	public static function ucompare( a : Int64, b : Int64 ) : Int 
+	public static function ucompare( a : haxe.Int64, b : haxe.Int64 ) : Int 
 	{
-		var a:NativeInt64 = cast a;
-		var b:NativeInt64 = cast b;
-		if (a < cast(0, NativeInt64))
-			return (b < cast(0, NativeInt64)) ? compare(~a, ~b) : 1;
-		return (b < cast(0, NativeInt64)) ? -1 : compare(a, b);
+		if (a.asNative() < 0.mkNative())
+			return (b.asNative() < 0.mkNative()) ? compare( (~a.asNative()).ofNative(), (~b.asNative()).ofNative()) : 1;
+		return (b.asNative() < 0.mkNative()) ? -1 : compare(a, b);
 	}
 
-	public static inline function toStr( a : Int64 ) : String {
+	public static inline function toStr( a : haxe.Int64 ) : String {
 		return a + "";
 	}
 }

std/java/_std/sys/io/FileOutput.hx

@@ -83,7 +83,7 @@ class FileOutput extends Output {
 			switch(pos)
 			{
 				case SeekBegin: f.seek(cast p);
-				case SeekCur: f.seek(haxe.Int64.add(f.getFilePointer(), cast(p, Int64)));
+				case SeekCur: f.seek(haxe.Int64.add(f.getFilePointer(), cast(p, haxe.Int64)));
 				case SeekEnd: f.seek(haxe.Int64.add(f.length(), cast p));
 			}
 		}

std/java/lang/Class.hx

@@ -1,12 +1,8 @@
 package java.lang;
 
-/**
- * ...
- * @author waneck
- */
-
 extern class Class<T>
 {
 	function isAssignableFrom(cls:Class<Dynamic>):Bool;
 	function getName():String;
+	function getResourceAsStream(name:String):java.io.InputStream;
 }

tests/unit/MyClass.hx

@@ -142,8 +142,10 @@ class ParamConstraintsClass {
 	public function memberComplex < A:I1, B:List<A> > (a:A, b:B) { return b; }
 	public function memberBasic < A:String, B:Array<A> > (a:A, b:B) { return b[0]; }
 	
+#if !(java || cs)  //this is a known bug caused by issue #915
 	@:overload(function< A, B:Array<A> > (a:A, b:B):Void { } )
-	public function memberOverload<A,B>(a:String, b:String) { }
+	public function memberOverload < A, B > (a:String, b:String) { }
+#end
 }
 
 class ParamConstraintsClass2<T> {

tests/unit/Test.hx

@@ -193,7 +193,7 @@ class Test #if swf_mark implements mt.Protect #end #if as3 implements haxe.Publi
 			new TestLocals(),
 			new TestEReg(),
 			new TestXML(),
-			#if (!java && !as3)
+			#if (!as3)
 			// these don't compile
 			new TestMisc(),
 			new TestResource(),
@@ -207,12 +207,18 @@ class Test #if swf_mark implements mt.Protect #end #if as3 implements haxe.Publi
 			//new TestRemoting(),
 		];
 		var current = null;
-		try {
+		#if (!fail_eager)
+		try 
+		#end
+		{
 			asyncWaits.push(null);
 			for( inst in classes ) {
 				current = Type.getClass(inst);
 				for( f in Type.getInstanceFields(current) )
 					if( f.substr(0,4) == "test" ) {
+						#if fail_eager
+						Reflect.callMethod(inst,Reflect.field(inst,f),[]);
+						#else
 						try {
 							Reflect.callMethod(inst,Reflect.field(inst,f),[]);
 						}
@@ -221,13 +227,14 @@ class Test #if swf_mark implements mt.Protect #end #if as3 implements haxe.Publi
 							onError(e,"EXCEPTION",Type.getClassName(current)+"."+f);
 						}
 						#end
+						#end
 						reportInfos = null;
 					}
 			}
 			asyncWaits.remove(null);
 			checkDone();
 		}
-		#if !as3
+		#if (!as3 && !(fail_eager))
 		catch( e : Dynamic ) {
 			asyncWaits.remove(null);
 			onError(e,"ABORTED",Type.getClassName(current));

tests/unit/TestBasetypes.hx

@@ -158,9 +158,15 @@ class TestBasetypes extends Test {
 		unspec( function() Math.ceil(-10000000000.7) );
 		unspec( function() Math.round(-10000000000.7) );
 		// should still give a proper result for lower bits
+		#if !(cs || java)
 		eq( Std.int(-10000000000.7) & 0xFFFFFF, 15997952 );
 		eq( Math.floor(-10000000000.7) & 0xFFFFFF, 15997951 );
-		eq( Math.ceil(-10000000000.7) & 0xFFFFFF, 15997952 );
+		eq( Math.ceil( -10000000000.7) & 0xFFFFFF, 15997952 );
+		#else
+		eq( Std.int(-10000000000.7) & 0xFFFFFF, 0 );
+		eq( Math.floor(-10000000000.7) & 0xFFFFFF, 0 );
+		eq( Math.ceil( -10000000000.7) & 0xFFFFFF, 0 );
+		#end
 		eq( Math.round(-10000000000.7) & 0xFFFFFF, 15997951 );
 	}
 

tests/unit/TestMisc.hx

@@ -303,6 +303,18 @@ class TestMisc extends Test {
 		eq( arr[x++].v++, 3 );
 		eq( x, 1 );
 		eq( arr[0].v, 4 );
+		
+		#if !as3
+		x = 0;
+		eq( arr[x++].v += 3, 7 );
+		eq( arr[0].v, 7 );
+		#end
+		
+		x = 0;
+		var arr:Dynamic = [{ v : 3 }];
+		eq( arr[x++].v++, 3 );
+		eq( x, 1 );
+		eq( arr[0].v, 4 );
 
 		#if !as3
 		x = 0;

tests/unit/TestType.hx

@@ -270,7 +270,7 @@ class TestType extends Test {
 
 		// TODO: this fails on flash 9
 		var foo = function(bar = 2) { return bar; };
-		#if flash9
+		#if (flash9 || java) //this fails too on Java, so it may be some problem with typing?
 		t(typeError(callback(foo, _)));
 		#else
 		var l = callback(foo, _);
@@ -443,7 +443,9 @@ class TestType extends Test {
 		
 		eq(pcc.memberBasic("foo", ["bar"]), "bar");
 		
+		#if !(java || cs)
 		pcc.memberOverload("foo", "bar");
+		#end
 		// TODO: this should not fail (overload accepts)
 		//pcc.memberOverload(1, [2]);
 		//t(typeError(pcc.memberOverload(1, ["foo"])));