Merge branch 'HaxeFoundation:master' into funkin-dev

Author: EliteMasterEric

TestHScript.hx

@@ -73,6 +73,7 @@ class TestHScript extends TestCase {
 		assertScript("3 * 2 // + 5 \n + 6",12);
 		assertScript("3 /* 2\n */ + 5",8);
 		assertScript("[55,66,77][1]",66);
+		assertScript("[11,22,33,][2]", 33);
 		assertScript("var a = [55]; a[0] *= 2; a[0]",110);
 		assertScript("x",55,{ x : 55 });
 		assertScript("var y = 33; y",33);

hscript/Bytes.hx

@@ -122,7 +122,7 @@ class Bytes {
 		doEncodeInt(e.line);
 		var e = e.e;
 		#end
-		bout.addByte(Type.enumIndex(e));
+		bout.addByte(exprIndex(e));
 		switch( e ) {
 		case EConst(c):
 			doEncodeConst(c);
@@ -173,6 +173,9 @@ class Bytes {
 			doEncodeString(v);
 			doEncode(it);
 			doEncode(e);
+		case EForGen(it,e):
+			doEncode(it);
+			doEncode(e);
 		case EBreak, EContinue:
 		case EFunction(params,e,name,_):
 			bout.addByte(params.length);
@@ -235,6 +238,39 @@ class Bytes {
 		}
 	}
 
+	function exprIndex(e):Int {
+		return switch (e) {
+			case EConst(_): 0;
+			case EIdent(_): 1;
+			case EVar(_): 2;
+			case EParent(_): 3;
+			case EBlock(_): 4;
+			case EField(_): 5;
+			case EBinop(_): 6;
+			case EUnop(_): 7;
+			case ECall(_): 8;
+			case EIf(_): 9;
+			case EWhile(_): 10;
+			case EFor(_): 11;
+			case EBreak: 12;
+			case EContinue: 13;
+			case EFunction(_): 14;
+			case EReturn(_): 15;
+			case EArray(_): 16;
+			case EArrayDecl(_): 17;
+			case ENew(_): 18;
+			case EThrow(_): 19;
+			case ETry(_): 20;
+			case EObject(_): 21;
+			case ETernary(_): 22;
+			case ESwitch(_): 23;
+			case EDoWhile(_): 24;
+			case EMeta(_): 25;
+			case ECheckType(_): 26;
+			case EForGen(_): 27;
+		}
+	}
+
 	function doDecode() : Expr {
 	#if hscriptPos
 		if (bin.get(pin) == 255) {
@@ -362,6 +398,8 @@ class Bytes {
 			EMeta(name, args, doDecode());
 		case 26:
 			ECheckType(doDecode(), CTPath(["Void"]));
+		case 27:
+			EForGen(doDecode(), doDecode());
 		case 255:
 			null;
 		default:

hscript/Checker.hx

@@ -77,6 +77,8 @@ typedef CTypedef = {> CNamedType,
 
 typedef CAbstract = {> CNamedType,
 	var t : TType;
+	var from : Array<TType>;
+	var to : Array<TType>;
 }
 
 class Completion {
@@ -233,13 +235,21 @@ class CheckerTypes {
 				name : a.path,
 				params : [],
 				t : null,
+				from : [],
+				to : [],
 			};
 			addMeta(a,ta);
 			for( p in a.params )
 				ta.params.push(TParam(p));
 			todo.push(function() {
 				localParams = [for( t in ta.params ) a.path+"."+Checker.typeStr(t) => t];
 				ta.t = makeXmlType(a.athis);
+				for( f in a.from )
+					if( f.field == null )
+						ta.from.push(makeXmlType(f.t));
+				for( t in a.to )
+					if( t.field == null )
+						ta.to.push(makeXmlType(t.t));
 				localParams = null;
 			});
 			types.set(a.path, CTAbstract(ta));
@@ -338,15 +348,22 @@ class Checker {
 		this.types = types;
 	}
 
-	public function setGlobals( cl : CClass, allowPrivate = false ) {
+	public function setGlobals( cl : CClass, ?params : Array<TType>, allowPrivate = false ) {
+		if( params == null )
+			params = [for( p in cl.params ) makeMono()];
 		while( true ) {
 			for( f in cl.fields )
 				if( f.isPublic || allowPrivate )
-					setGlobal(f.name, f.params.length == 0 ? f.t : TLazy(function() return apply(f.t,f.params,[for( i in 0...f.params.length) makeMono()])));
+					setGlobal(f.name, f.params.length == 0 ? f.t : TLazy(function() {
+						var t = apply(f.t,f.params,[for( i in 0...f.params.length) makeMono()]);
+						return apply(t, cl.params, params);
+					}));
 			if( cl.superClass == null )
 				break;
 			cl = switch( cl.superClass ) {
-			case TInst(c,_): c;
+			case TInst(csup,pl):
+				params = [for( p in pl ) apply(p,cl.params,params)];
+				csup;
 			default: throw "assert";
 			}
 		}
@@ -465,6 +482,9 @@ class Checker {
 			return makeType(t,e);
 		case CTOpt(t):
 			return makeType(t,e);
+		case CTExpr(_):
+			error("Unsupported expr type parameter", e);
+			return null;
 		}
 	}
 
@@ -722,6 +742,18 @@ class Checker {
 			return true;
 		case [TFun(_), TAbstract({ name : "haxe.Function" },_)]:
 			return true;
+		case [_, TAbstract(a, args)]:
+			for( ft in a.from ) {
+				var t = apply(ft,a.params,args);
+				if( tryUnify(t1,t) )
+					return true;
+			}
+		case [TAbstract(a, args), _]:
+			for( tt in a.to ) {
+				var t = apply(tt,a.params,args);
+				if( tryUnify(t,t2) )
+					return true;
+			}
 		default:
 		}
 		return typeEq(t1,t2);
@@ -1185,11 +1217,26 @@ class Checker {
 		case EFor(v, it, e):
 			var locals = saveLocals();
 			var itt = typeExpr(it, Value);
-			var vt = getIteratorType(it, itt);
+			var vt = getIteratorType(itt, it);
 			this.locals.set(v, vt);
 			typeExpr(e, NoValue);
 			this.locals = locals;
 			return TVoid;
+		case EForGen(it, e):
+			Tools.getKeyIterator(it,function(vk,vv,it) {
+				if( vk == null ) {
+					error("Invalid for expression", it);
+					return;
+				}
+				var locals = saveLocals();
+				var itt = typeExpr(it, Value);
+				var types = getKeyIteratorTypes(itt, it);
+				this.locals.set(vk, types.key);
+				this.locals.set(vv, types.value);
+				typeExpr(e, NoValue);
+				this.locals = locals;
+			});
+			return TVoid;
 		case EBinop(op, e1, e2):
 			switch( op ) {
 			case "&", "|", "^", ">>", ">>>", "<<":
@@ -1320,7 +1367,7 @@ class Checker {
 		return TDynamic;
 	}
 
-	function getIteratorType( it : Expr, itt : TType ) {
+	function getIteratorType( itt : TType, it : Expr ) {
 		switch( follow(itt) ) {
 		case TInst({name:"Array"},[t]):
 			return t;
@@ -1333,7 +1380,7 @@ class Checker {
 				// special case : we allow unconditional access
 				// to an abstract iterator() underlying value (eg: ArrayProxy)
 				var at = apply(a.t,a.params,args);
-				return getIteratorType(it, at);
+				return getIteratorType(at, it);
 			default:
 			}
 		if( ft != null )
@@ -1347,4 +1394,34 @@ class Checker {
 		return t;
 	}
 
+
+	function getKeyIteratorTypes( itt : TType, it : Expr ) {
+		switch( follow(itt) ) {
+		case TInst({name:"Array"},[t]):
+			return { key : TInt, value : t };
+		default:
+		}
+		var ft = getField(itt,"keyValueIterator", it);
+		if( ft == null )
+			switch( itt ) {
+			case TAbstract(a, args):
+				// special case : we allow unconditional access
+				// to an abstract keyValueIterator() underlying value (eg: ArrayProxy)
+				var at = apply(a.t,a.params,args);
+				return getKeyIteratorTypes(at, it);
+			default:
+			}
+		if( ft != null )
+			switch( ft ) {
+			case TFun([],ret): ft = ret;
+			default: ft = null;
+			}
+		var key = makeMono();
+		var value = makeMono();
+		var iter = makeIterator(TAnon([{name:"key",t:key,opt:false},{name:"value",t:value,opt:false}]));
+		unify(ft != null ? ft : itt,iter,it);
+		return { key : key, value : value };
+	}
+
+
 }

hscript/Expr.hx

@@ -67,6 +67,7 @@ enum Expr {
 	EDoWhile( cond : Expr, e : Expr);
 	EMeta( name : String, args : Array<Expr>, e : Expr );
 	ECheckType( e : Expr, t : CType );
+	EForGen( it : Expr, e : Expr );
 }
 
 typedef Argument = { name : String, ?t : CType, ?opt : Bool, ?value : Expr };
@@ -80,6 +81,7 @@ enum CType {
 	CTParent( t : CType );
 	CTOpt( t : CType );
 	CTNamed( n : String, t : CType );
+	CTExpr( e : Expr ); // for type parameters only
 }
 
 #if hscriptPos

hscript/Interp.hx

@@ -365,6 +365,18 @@ class Interp {
 		case EFor(v,it,e):
 			forLoop(v,it,e);
 			return null;
+		case EForGen(it,e):
+			Tools.getKeyIterator(it, function(vk,vv,it) {
+				if( vk == null ) {
+					#if hscriptPos
+					curExpr = it;
+					#end
+					error(ECustom("Invalid for expression"));
+					return;
+				}
+				forKeyValueLoop(vk,vv,it,e);
+			});
+			return null;
 		case EBreak:
 			throw SBreak;
 		case EContinue:
@@ -555,9 +567,7 @@ class Interp {
 	}
 
 	function makeIterator( v : Dynamic ) : Iterator<Dynamic> {
-		#if ((flash && !flash9) || (php && !php7 && haxe_ver < '4.0.0'))
-		if ( v.iterator != null ) v = v.iterator();
-		#elseif js
+		#if js
 		// don't use try/catch (very slow)
 		if( v is Array )
 			return (v : Array<Dynamic>).iterator();
@@ -570,6 +580,19 @@ class Interp {
 		return v;
 	}
 
+	function makeKeyValueIterator( v : Dynamic ) : KeyValueIterator<Dynamic,Dynamic> {
+		#if js
+		// don't use try/catch (very slow)
+		if( v is Array )
+			return (v : Array<Dynamic>).keyValueIterator();
+		if( v.keyValueIterator != null ) v = v.keyValueIterator();
+		#else
+		try v = v.keyValueIterator() catch( e : Dynamic ) {};
+		#end
+		if( v.hasNext == null || v.next == null ) error(EInvalidIterator(v));
+		return v;
+	}
+
 	function forLoop(n,it,e) {
 		var old = declared.length;
 		declared.push({ n : n, old : locals.get(n) });
@@ -582,6 +605,21 @@ class Interp {
 		restore(old);
 	}
 
+	function forKeyValueLoop(vk,vv,it,e) {
+		var old = declared.length;
+		declared.push({ n : vk, old : locals.get(vk) });
+		declared.push({ n : vv, old : locals.get(vv) });
+		var it = makeKeyValueIterator(expr(it));
+		while( it.hasNext() ) {
+			var v = it.next();
+			locals.set(vk,{ r : v.key });
+			locals.set(vv,{ r : v.value });
+			if( !loopRun(() -> expr(e)) )
+				break;
+		}
+		restore(old);
+	}
+
 	inline function loopRun( f : Void -> Void ) {
 		var cont = true;
 		try {

hscript/Macro.hx

@@ -90,7 +90,7 @@ class Macro {
 		}
 	}
 
-	function map < T, R > ( a : Array<T>, f : T -> R ) : Array<R> {
+	function map<T,R>( a : Array<T>, f : T -> R ) : Array<R> {
 		var b = new Array();
 		for( x in a )
 			b.push(f(x));
@@ -102,9 +102,13 @@ class Macro {
 		case CTOpt(t): TOptional(convertType(t));
 		case CTPath(pack, args):
 			var params = [];
-			if( args != null )
+			if( args != null ) {
 				for( t in args )
-					params.push(TPType(convertType(t)));
+					params.push(switch( t ) {
+					case CTExpr(e): TPExpr(convert(e));
+					default: TPType(convertType(t));
+					});
+			}
 			TPath({
 				pack : pack,
 				name : pack.pop(),
@@ -127,6 +131,8 @@ class Macro {
 				tf.push( { name : f.name, meta : meta, doc : null, access : [], kind : FVar(convertType(f.t), null), pos : p } );
 			}
 			TAnonymous(tf);
+		case CTExpr(_):
+			throw "assert";
 		};
 	}
 
@@ -165,13 +171,10 @@ class Macro {
 			case EDoWhile(c, e):
 				EWhile(convert(c), convert(e), false);
 			case EFor(v, it, efor):
-				#if (haxe_ver >= 4)
-					var p = #if (!macro && hscriptPos) { file : p.file, min : e.pmin, max : e.pmax } #else p #end;
-					EFor({ expr : EBinop(OpIn,{ expr : EConst(CIdent(v)), pos : p },convert(it)), pos : p }, convert(efor));
-				#else
-					var p = #if (!macro && hscriptPos) { file : p.file, min : e.pmin, max : e.pmax } #else p #end;
-					EFor({ expr : EIn({ expr : EConst(CIdent(v)), pos : p },convert(it)), pos : p }, convert(efor));
-				#end
+				var p = #if (!macro && hscriptPos) { file : p.file, min : e.pmin, max : e.pmax } #else p #end;
+				EFor({ expr : EBinop(OpIn,{ expr : EConst(CIdent(v)), pos : p },convert(it)), pos : p }, convert(efor));
+			case EForGen(it, efor):
+				EFor(convert(it), convert(efor));
 			case EBreak:
 				EBreak;
 			case EContinue: