Fixes for HashLink

Author: NotHyper-474

polymod/hscript/_internal/HLWrapperMacro.hx

@@ -0,0 +1,147 @@
+package polymod.hscript._internal;
+
+import haxe.macro.MacroStringTools;
+import haxe.macro.TypedExprTools;
+import haxe.macro.Context;
+import haxe.macro.Expr;
+import haxe.macro.Type;
+
+using Lambda;
+using haxe.macro.TypeTools;
+using haxe.macro.ComplexTypeTools;
+using haxe.macro.ExprTools;
+using StringTools;
+
+#if (!macro && hl)
+@:build(polymod.hscript._internal.HLWrapperMacro.buildWrapperClass())
+class HLMath extends Math {}
+
+@:build(polymod.hscript._internal.HLWrapperMacro.buildWrapperClass())
+@:haxe.warning("-WDeprecated")
+class HLStd extends Std {}
+#else
+/**
+ * Macro that generates wrapper fields for substitutes of `std` classes to make them avaliable to Reflection.
+ * Currently only works for static fields.
+ */
+class HLWrapperMacro
+{
+	public static macro function buildWrapperClass():Array<Field>
+	{
+		var localClass = Context.getLocalClass().get();
+		var superClass = localClass.superClass;
+		if (superClass == null)
+			throw 'Class ${localClass.name} does not extend class it wants to wrap';
+		var cls = superClass.t.get();
+		var buildFields = Context.getBuildFields();
+
+		for (field in cls.statics.get())
+		{
+			if (field.isPublic && !buildFields.exists((f) -> f.name == field.name))
+			{
+				var wrapper = generateWrapper(field, cls);
+				if (wrapper != null)
+					buildFields.push(wrapper);
+			}
+		}
+
+		return buildFields;
+	}
+
+	static function generateWrapper(field:ClassField, cls:ClassType):Null<Field>
+	{
+		if (field == null)
+			throw 'Field is null';
+
+		var newField:Field = {
+			name: field.name,
+			doc: field.doc,
+			meta: null,
+			pos: field.pos,
+			access: [APublic, AStatic, AInline],
+			kind: null
+		};
+
+		function populateNewField(t:Type):Bool
+		{
+			return switch (t)
+			{
+				case TLazy(lz):
+					var ty = lz();
+					return populateNewField(ty);
+				case TFun(args, ret):
+					var funcArgs:Array<FunctionArg> = [
+						for (arg in args)
+							{
+								name: arg.name,
+								opt: arg.opt,
+								type: Context.toComplexType(arg.t)
+							}
+					];
+					var ret = Context.toComplexType(ret);
+					var callArgs:Array<Expr> = [for (arg in funcArgs) macro $i{arg.name}];
+					var funcParams:Array<TypeParamDecl> = [for (p in field.params) {name: p.name, constraints: getConstraints(p.t)}];
+					var body = macro $p{[cls.name, field.name]}($a{callArgs});
+
+					newField.kind = FFun({
+						args: funcArgs,
+						params: funcParams,
+						ret: ret,
+						expr: doesReturnVoid(ret) ? (macro $body) : (macro return $body)
+					});
+					return true;
+				default: false;
+			}
+		}
+
+		if (populateNewField(field.type))
+		{
+			return newField;
+		}
+		else if (field.expr() == null)
+		{
+			var overKind = switch (field.kind)
+			{
+				case FVar(_, _):
+					// We're overriding a VARIABLE, it shouldn't be modifiable
+					FieldType.FProp('default', 'null', Context.toComplexType(field.type), macro $p{[cls.name, field.name]});
+				default: throw "Not implemented!";
+			}
+
+			return {
+				name: field.name,
+				doc: field.doc,
+				meta: field.meta.get(),
+				pos: field.pos,
+				access: [APublic, AStatic],
+				kind: overKind
+			};
+		}
+
+		return null;
+	}
+
+	static function getConstraints(t:Type)
+	{
+		return switch (t)
+		{
+			case TInst(_.get() => c, _):
+				switch (c.kind)
+				{
+					case KTypeParameter(consts): [for (c in consts) Context.toComplexType(c)];
+					default: throw 'Invalid class kind, it is not a TypeParameter';
+				}
+			case _: throw '$t has not been implemented!';
+		}
+	}
+
+	static inline function doesReturnVoid(rt:ComplexType)
+	{
+		return switch (rt)
+		{
+			case TPath(tp): tp.name == "Void";
+			default: false;
+		}
+	}
+}
+#end

polymod/hscript/_internal/PolymodAbstractScriptClass.hx

@@ -198,6 +198,8 @@ abstract PolymodAbstractScriptClass(PolymodScriptClass) from PolymodScriptClass
 			@:privateAccess this._interp.error(EInvalidAccess(name));
 			// throw "field '" + name + "' does not exist in script class '" + this.fullyQualifiedName + "' or super class '" + Type.getClassName(Type.getClass(this.superClass)) + "'";
 		}
+		
+		return null;
 	}
 
 	private static function retrieveClassObjectFields(o:Dynamic):Array<String>

polymod/hscript/_internal/PolymodInterpEx.hx

@@ -41,8 +41,8 @@ class PolymodInterpEx extends Interp
 	{
 		super();
 		_proxy = proxy;
-		variables.set("Math", Math);
-		variables.set("Std", Std);
+		variables.set("Math", #if hl HLWrapperMacro.HLMath #else Math #end);
+		variables.set("Std", #if hl HLWrapperMacro.HLStd #else Std #end);
 		this.targetCls = targetCls;
 	}
 
@@ -1151,8 +1151,20 @@ class PolymodInterpEx extends Interp
 			// #end
 			// return result;
 		}
+		#if hl
+		else if (Std.isOfType(o, Enum))
+		{
+			try {
+				return (o:Enum<Dynamic>).createByName(f);
+			}
+			catch (e)
+			{
+				return null;
+			}
+		}
+		#end
 
-		var abstractKey:String = Type.getClassName(o) + '.' + f;
+		var abstractKey:String = #if hl untyped o.__name__ #else Type.getClassName(o) #end + '.' + f;
 		if (PolymodScriptClass.abstractClassStatics.exists(abstractKey)) {
 			return Reflect.getProperty(PolymodScriptClass.abstractClassStatics[abstractKey], abstractKey.replace('.', '_'));
 		}