a bug

ExampleJSGenerator.hx

/*
 * Copyright (C)2005-2019 Haxe Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

package;

import haxe.macro.Type;
import haxe.macro.Expr;
import haxe.macro.*;

using Lambda;

class ExampleJSGenerator {
	var api:JSGenApi;
	var buf:StringBuf;
	var inits:List<TypedExpr>;
	var statics:List<{c:ClassType, f:ClassField}>;
	var packages:haxe.ds.StringMap<Bool>;
	var forbidden:haxe.ds.StringMap<Bool>;

	public function new(api) {
		this.api = api;
		buf = new StringBuf();
		inits = new List();
		statics = new List();
		packages = new haxe.ds.StringMap();
		forbidden = new haxe.ds.StringMap();
		for (x in ["prototype", "__proto__", "constructor"])
			forbidden.set(x, true);
		api.setTypeAccessor(getType);
	}

	function getType(t:Type) {
		return switch (t) {
			case TInst(c, _): getPath(c.get());
			case TEnum(e, _): getPath(e.get());
			case TAbstract(a, _): getPath(a.get());
			default: throw "assert";
		};
	}

	inline function print(str:String) {
		buf.add(str);
	}

	inline function newline() {
		buf.add(";\n");
	}

	//{ issue subject: log expression types for locals
	function genExpr(e:TypedExpr) {
		function _iter(x:TypedExpr):Void {
			switch (x.expr) {
				case TLocal(v): {
					Context.warning("t=" + x.t + ", v.t=" + v.t, x.pos);
				};
				default:
			}
			TypedExprTools.iter(x, _iter);
		}
		TypedExprTools.iter(e, _iter);
		print(api.generateValue(e));
	}
	//}

	function field(p) {
		return api.isKeyword(p) ? '["' + p + '"]' : "." + p;
	}

	function genPackage(p:Array<String>) {
		var full = null;
		for (x in p) {
			var prev = full;
			if (full == null)
				full = x
			else
				full += "." + x;
			if (packages.exists(full))
				continue;
			packages.set(full, true);
			if (prev == null)
				print('if(typeof $x==\'undefined\') $x = {}');
			else {
				var p = prev + field(x);
				print('if(!$p) $p = {}');
			}
			newline();
		}
	}

	function getPath(t:BaseType) {
		return (t.pack.length == 0) ? t.name : t.pack.join(".") + "." + t.name;
	}

	function checkFieldName(c:ClassType, f:ClassField) {
		if (forbidden.exists(f.name))
			Context.error("The field " + f.name + " is not allowed in JS", c.pos);
	}

	function genClassField(c:ClassType, p:String, f:ClassField) {
		checkFieldName(c, f);
		var field = field(f.name);
		print('$p.prototype$field = ');
		var e = f.expr();
		if (e == null)
			print("null");
		else {
			genExpr(e);
		}
		newline();
	}

	function genStaticField(c:ClassType, p:String, f:ClassField) {
		checkFieldName(c, f);
		var field = field(f.name);
		var e = f.expr();
		if (e == null) {
			print('$p$field = null');
			newline();
		} else
			switch (f.kind) {
				case FMethod(_):
					print('$p$field = ');
					genExpr(e);
					newline();
				default:
					statics.add({c: c, f: f});
			}
	}

	function genClass(c:ClassType) {
		genPackage(c.pack);
		api.setCurrentClass(c);
		var p = getPath(c);
		print('$p = $$hxClasses[\'$p\'] = ');
		if (c.constructor != null)
			genExpr(c.constructor.get().expr());
		else
			print("function() { }");
		newline();
		print('$p.__name__ = "$p"');
		newline();
		if (c.superClass != null) {
			var psup = getPath(c.superClass.t.get());
			print('$p.__super__ = $psup');
			newline();
			print('for(var k in $psup.prototype ) $p.prototype[k] = $psup.prototype[k]');
			newline();
		}
		for (f in c.statics.get())
			genStaticField(c, p, f);
		for (f in c.fields.get()) {
			switch (f.kind) {
				case FVar(r, _):
					if (r == AccResolve)
						continue;
				default:
			}
			genClassField(c, p, f);
		}
		print('$p.prototype.__class__ = $p');
		newline();
		if (c.interfaces.length > 0) {
			var me = this;
			var inter = c.interfaces.map(function(i) return me.getPath(i.t.get())).join(",");
			print('$p.__interfaces__ = [$inter]');
			newline();
		}
	}

	function genEnum(e:EnumType) {
		genPackage(e.pack);
		var p = getPath(e);
		var constructs = e.names.map(api.quoteString).join(",");
		print('$p = $$hxClasses[\'$p\'] = { __ename__ : \'$p\', __constructs__ : [$constructs] }');
		newline();
		for (c in e.constructs.keys()) {
			var c = e.constructs.get(c);
			var f = field(c.name);
			print('$p$f = ');
			switch (c.type) {
				case TFun(args, _):
					var sargs = args.map(function(a) return a.name).join(",");
					print('function($sargs) { var $$x = ["${c.name}",${c.index},$sargs]; $$x.__enum__ = $p; $$x.toString = $$estr; return $$x; }');
				default:
					print("[" + api.quoteString(c.name) + "," + c.index + "]");
					newline();
					print('$p$f.toString = $$estr');
					newline();
					print('$p$f.__enum__ = $p');
			}
			newline();
		}
		var meta = api.buildMetaData(e);
		if (meta != null) {
			print('$p.__meta__ = ');
			genExpr(meta);
			newline();
		}
	}

	function genStaticValue(c:ClassType, cf:ClassField) {
		var p = getPath(c);
		var f = field(cf.name);
		print('$p$f = ');
		genExpr(cf.expr());
		newline();
	}

	function genType(t:Type) {
		switch (t) {
			case TInst(c, _):
				var c = c.get();
				if (c.init != null)
					inits.add(c.init);
				if (!c.isExtern)
					genClass(c);
			case TEnum(r, _):
				var e = r.get();
				if (!e.isExtern)
					genEnum(e);
			default:
		}
	}

	public function generate() {
		print("var $_, $hxClasses = $hxClasses || {}, $estr = function() { return js.Boot.__string_rec(this,''); }");
		newline();
		print("function $bind(o,m) { var f = function(){ return f.method.apply(f.scope, arguments); }; f.scope = o; f.method = m; return f; };");
		newline();
		for (t in api.types)
			genType(t);
		for (e in inits) {
			print(api.generateStatement(e));
			newline();
		}
		for (s in statics) {
			genStaticValue(s.c, s.f);
			newline();
		}
		if (api.main != null) {
			genExpr(api.main);
			newline();
		}
		sys.io.File.saveContent(api.outputFile, buf.toString());
	}

	#if (macro || display)
	public static function use() {
		Compiler.setCustomJSGenerator(function(api) new ExampleJSGenerator(api).generate());
	}
	#end
}

Main.hx

class Main {
	static function main() {
		var a:TestAb = {s:"hi!"};
		if (a != null) {
			trace(a.s);
		}
		var b:TestTd = {s:"hello!"};
		if (b != null) {
			trace(b.s);
		}
	}
}
@:forward abstract TestAb(TestTd) from TestTd {
	//
}
@:keep typedef TestTd = {
	var s:String;
}

main.hxml

haxe  -cp src -js test.js -main Main --macro ExampleJSGenerator.use()