Fix "using" classes calling their function on the wrong type

Author: NotHyper-474

include.xml

@@ -4,6 +4,7 @@
   <haxelib name="thx.semver" />
   <!-- <haxelib name="hscript" /> This library is now OPTIONAL. -->
 
+  <haxeflag name="--macro" value="polymod.hscript._internal.UsingRttiMacro.addRtti()" />
   <!--
     <haxeflag name="- -macro" value="polymod.hscript._internal.PolymodFinalMacro.locateAllFinals()" />
   -->

polymod/hscript/_internal/PolymodInterpEx.hx

@@ -153,16 +153,17 @@ class PolymodInterpEx extends Interp
 			return proxy.callFunction(f, args);
 		}
 
-		var func = get(o, f);
-
 		@:privateAccess
 		{
 			if (_proxy != null && _proxy._cachedUsingFunctions.exists(f))
 			{
-				return _proxy._cachedUsingFunctions[f]([o].concat(args));
+				var func = _proxy._cachedUsingFunctions[f];
+				if (func.type == null || Std.isOfType(o, func.type)) return func.func([o].concat(args));
 			}
 		}
 
+		var func = get(o, f);
+
 		// Workaround for an HTML5-specific issue.
 		// https://github.com/HaxeFoundation/haxe/issues/11298
 		if (func == null && f == "contains") {

polymod/hscript/_internal/PolymodScriptClass.hx

@@ -1,12 +1,15 @@
 package polymod.hscript._internal;
 
 #if hscript
+import haxe.Constraints.Function;
+import haxe.rtti.Rtti;
 import hscript.Expr.FieldDecl;
 import hscript.Expr.FunctionDecl;
 import hscript.Expr.VarDecl;
 import hscript.Printer;
 import polymod.hscript._internal.PolymodClassDeclEx;
 
+using haxe.rtti.CType.CTypeTools;
 using StringTools;
 
 enum Param
@@ -885,7 +888,7 @@ class PolymodScriptClass
 	private var _cachedSuperFunctionDecls:Map<String, Dynamic> = [];
 	private var _cachedFunctionDecls:Map<String, FunctionDecl> = [];
 	private var _cachedVarDecls:Map<String, VarDecl> = [];
-	private var _cachedUsingFunctions:Map<String, Dynamic> = [];
+	private var _cachedUsingFunctions:Map<String, {type:Null<Class<Dynamic>>, func:Dynamic}> = [];
 
 	private function buildCaches()
 	{
@@ -895,20 +898,46 @@ class PolymodScriptClass
 		_cachedVarDecls.clear();
 		_cachedUsingFunctions.clear();
 
-		for (n => u in _c.usings)
+		for (_ => u in _c.usings)
 		{
-			var fields = Type.getClassFields(u.cls);
-			if (fields.length == 0) continue;
+			if (Rtti.hasRtti(u.cls))
+			{
+				var fields = Rtti.getRtti(u.cls).statics;
+				if (fields.length == 0) continue;
+
+				for (fld in fields)
+				{
+					var usingType:Null<Class<Dynamic>> = null;
+					switch (fld.type)
+					{
+						case CFunction(args, _): usingType = Type.resolveClass(args[0].t.toString());
+						default:
+					}
+					var func:Dynamic = function(params:Array<Dynamic>)
+					{
+						var prop:Dynamic = Reflect.getProperty(u.cls, fld.name);
+						return Reflect.callMethod(u.cls, prop, params);
+					}
 
-			for (fld in fields)
+					_cachedUsingFunctions.set(fld.name, { type: usingType, func: func });
+				}
+			}
+			else
 			{
-				var func:Dynamic = function(params:Array<Dynamic>)
+				// We make fields for it anyway and pray they work on other targets
+				var fields = Type.getClassFields(u.cls);
+				if (fields.length == 0) continue;
+
+				for (fld in fields)
 				{
-					var prop:Dynamic = Reflect.getProperty(u.cls, fld);
-					return Reflect.callMethod(u.cls, prop, params);
+					var func:Dynamic = function(params:Array<Dynamic>)
+					{
+						var prop:Dynamic = Reflect.getProperty(u.cls, fld);
+						return Reflect.callMethod(u.cls, prop, params);
+					}
+
+					_cachedUsingFunctions.set(fld, { type: null, func: func });
 				}
-					
-				_cachedUsingFunctions.set(fld, func);
 			}
 		}
 

polymod/hscript/_internal/UsingRttiMacro.hx

@@ -0,0 +1,37 @@
+package polymod.hscript._internal;
+
+import haxe.macro.Context;
+import haxe.macro.Type;
+import haxe.macro.Expr;
+
+using haxe.macro.TypeTools;
+
+/**
+ * Automatically adds the @:rtti metadata to classes with "Tools" or "Util" in their name
+ */
+class UsingRttiMacro
+{
+    public static macro function addRtti():Void
+    {
+        Context.onGenerate((types) ->
+        {
+            for (type in types)
+            {
+                if (shouldAddRtti(type))
+                {
+                    switch (type)
+                    {
+                        case TInst(_.get() => cls, _):
+                            cls.meta.add(':rtti', [], cls.pos);
+                        case _:
+                    }
+                }
+            }
+        });
+    }
+
+    private static function shouldAddRtti(type:haxe.macro.Type):Bool {
+        final name = type.toString();
+        return name.indexOf("Tools") != -1 || name.indexOf("Util") != -1;
+    }
+}