that macro took me 3 hours

extraParams.hxml

@@ -1 +1,2 @@
---macro keep('IntIterator')
+--macro keep('IntIterator')
+--macro hscript.UsingHandler.init()

hscript/Interp.hx

@@ -442,6 +442,9 @@ class Interp {
 				if (importBlocklist.contains(realClassName))
 					return null; 
 				var cl = Type.resolveClass(realClassName);
+				if (cl == null)
+					cl = Type.resolveClass('${realClassName}_HSC');
+
 				var en = Type.resolveEnum(realClassName);
 
 				if (cl == null && en == null) {

hscript/UsingHandler.hx

@@ -0,0 +1,110 @@
+package hscript;
+
+import Type.ValueType;
+import haxe.macro.ComplexTypeTools;
+#if macro
+import haxe.macro.Expr;
+import haxe.macro.Context;
+import haxe.macro.Printer;
+import haxe.macro.Compiler;
+
+using StringTools;
+
+class UsingHandler {
+    public var usedClass:Class<Dynamic>;
+    public var className:String;
+
+    public function new(className:String, usedClass:Class<Dynamic>) {
+        this.className = className;
+        this.usedClass = usedClass;
+    }
+
+    public function testingStuff() {
+
+    }
+
+    public static function init() {
+        Compiler.addGlobalMetadata('', '@:build(hscript.UsingHandler.build())');
+    }
+
+    public static function build():Array<Field> {
+        var fields = Context.getBuildFields();
+        var clRef = Context.getLocalClass();
+        if (clRef == null) return fields;
+        var cl = clRef.get();
+
+        if (cl.name.startsWith("Flx") && cl.name.endsWith("_Impl_") && cl.params.length <= 0 && !cl.meta.has(":multiType")) {
+            var metas = cl.meta.get();
+
+            var shadowClass = macro class {
+                
+            };
+            shadowClass.params = switch(cl.params.length) {
+                case 0:
+                    null;
+                case 1:
+                    [
+                        {
+                            name: "T",
+                        }
+                    ];
+                default:
+                    [for(k=>e in cl.params) {
+                        name: "T" + Std.int(k+1)
+                    }];
+            };
+            shadowClass.name = '${cl.name.substr(0, cl.name.length - 6)}_HSC';
+
+            for(f in fields)
+                switch(f.kind) {
+                    case FFun(fun):
+                        if (f.access.contains(AStatic)) {
+                            if (fun.expr != null)
+                                shadowClass.fields.push(f);
+                        }
+                    case FProp(get, set, t, e):
+                        if (get == "default" && (set == "never" || set == "null"))
+                            shadowClass.fields.push(f);
+                    case FVar(t, e):
+                        if (f.access.contains(AStatic) || cl.meta.has(":enum") || f.name.toUpperCase() == f.name) {
+                            var name:String = f.name;
+                            var enumType:String = cl.name;
+                            var pack = cl.module.split(".");
+                            pack.pop();
+                            var complexType:ComplexType = t != null ? t : (name.contains("REGEX") ? TPath({
+                                name: "EReg",
+                                pack: []
+                            }) : TPath({
+                                name: cl.name.substr(0, cl.name.length - 6),
+                                pack: pack}));
+                            var field:Field = {
+                                pos: f.pos,
+                                name: f.name,
+                                meta: f.meta,
+                                kind: FVar(complexType, {
+                                    pos: Context.currentPos(),
+                                    expr: ECast(e, complexType)
+                                }),
+                                doc: f.doc,
+                                access: [APublic, AStatic]
+                            }
+                            
+                            shadowClass.fields.push(field);
+                        }
+                    default:
+                }
+
+            var p = new Printer();
+            trace(p.printTypeDefinition(shadowClass));
+            Context.defineModule(cl.module, [shadowClass], Context.getLocalImports());
+        }
+
+        return fields;
+    }
+}
+#else
+class UsingHandler {
+    public var usedClass:Class<Dynamic>;
+    public var className:String;
+}
+#end