shit from an ass that refuses to work with FileUtil

NotHyper-474 · NotHyper-474 · commit 4430b1686948 · 2025-11-12T21:56:35.000-03:00
diff --git a/source/funkin/util/ReflectUtil.hx b/source/funkin/util/ReflectUtil.hx
@@ -5,7 +5,6 @@ package funkin.util;
  * Used for sandboxing in scripts.
  */
 @:nullSafety
-@SuppressWarnings("checkstyle:VarTypeHint")
 @:build(funkin.util.macro.BlacklistClassMacro.build(
   {
     classes: ["Reflect", "Type"],
@@ -34,8 +33,7 @@ package funkin.util;
       "isObject",
       "setField",
       "setProperty"
-    ],
-    whitelistMode: true
+    ]
   }))
 class ReflectUtil
 {
diff --git a/source/funkin/util/macro/BlacklistClassMacro.hx b/source/funkin/util/macro/BlacklistClassMacro.hx
@@ -10,6 +10,9 @@ import haxe.DynamicAccess;
 using haxe.macro.TypeTools;
 using haxe.macro.ComplexTypeTools;
 using Lambda;
+using StringTools;
+
+typedef Either<T, V> = Dynamic;
 
 typedef WrapperParams =
 {
@@ -47,7 +50,7 @@ typedef WrapperParams =
 /**
  * Generates fields that wrap functions from the provided classes in a way that
  * they'll throw an error if accessed or call the original function if whitelisted.
- * It is only intended to be used with classes with only static functions.
+ * It is best to be used with classes with only static fields.
  *
  * You can add your own sandboxed implementations of the fields and make aliases to them (see `BlacklistParams.aliases`).
  */
@@ -63,42 +66,52 @@ class BlacklistClassMacro
     params.whitelistMode ??= true;
     params.fieldList ??= [];
 
+    final classes:Array<ClassType> = [for (c in params.classes) MacroUtil.getClassType(c)];
+    if (classes.length == 0) Context.fatalError('Invalid class amount, no classes were provided.', Context.currentPos());
+
     final buildFields:Array<Field> = Context.getBuildFields();
     final generatedFields:Array<Field> = [];
 
-    final classes:Array<ClassType> = [for (c in params.classes) MacroUtil.getClassType(c)];
-    if (classes.length == 0) Context.fatalError('Invalid class amount, no classes were provided.', Context.currentPos());
+    // For convenience...
+    inline function containsField(fieldName:String):Bool
+    {
+      return buildFields.exists(f -> f.name == fieldName);
+    }
+    inline function getField(fieldName:String):Null<Field>
+    {
+      return buildFields.find(f -> f.name == fieldName);
+    }
 
     // NOTE: As much as I wish these could be a map seems like Haxe is unable to parse them as part of the metadata.
     final aliases:DynamicAccess<Array<String>> = cast params.aliases;
-    final aliasedFields:Array<String> = params.ignoreList?.copy() ?? [];
-    final fieldsToWrap:Array<String> = [];
+    final fieldsToSkip:Array<String> = params.ignoreList?.copy() ?? [];
+    final pendingFieldsToWrap:Array<String> = [];
     if (aliases != null)
     {
       for (field => aliasFields in aliases)
       {
         if (aliasFields.length == 0) Context.warning('No alias fields specified to be generated for "$field"', Context.currentPos());
 
-        final wrappedField:Null<Field> = getField(buildFields, field);
+        final wrappedField:Null<Field> = getField(field);
         if (wrappedField == null)
         {
           // Field might be on the provided classes, put it on queue.
-          fieldsToWrap.push(field);
+          pendingFieldsToWrap.push(field);
           continue;
         }
 
         for (aliasName in aliasFields)
         {
-          if (containsField(buildFields, aliasName))
+          if (containsField(aliasName))
           {
-            Context.error('Tried to generate "${aliasName}" alias but it already exists in the class.', getField(buildFields, aliasName).pos);
+            Context.error('Tried to generate "${aliasName}" alias but it already exists in the class.', getField(aliasName).pos);
           }
 
-          final wrapper:Null<Field> = generateWrapperFunction(aliasName, wrappedField);
+          final wrapper:Null<Field> = generateWrapperField(aliasName, wrappedField);
           if (wrapper != null)
           {
             generatedFields.push(wrapper);
-            aliasedFields.push(aliasName);
+            fieldsToSkip.push(aliasName);
           }
           else
             Context.error('Could not generate alias for field "$field"; it may not be a function.', wrappedField.pos);
@@ -110,174 +123,164 @@ class BlacklistClassMacro
     {
       for (field in c.statics.get())
       {
-        if (!field.isPublic || aliasedFields.contains(field.name)) continue;
+        if (!field.isPublic || fieldsToSkip.contains(field.name)) continue;
 
-        if (containsField(buildFields, field.name))
+        if (containsField(field.name))
         {
-          if (!getField(buildFields, field.name).meta.exists(m -> m.name == ':blacklistOverride'))
+          if (!getField(field.name).meta.exists(m -> m.name == ':blacklistOverride'))
           {
             // 'reportError' doesn't abort compilation, so it allows us to see all the duplicate fields!
             Context.reportError('Tried to generate "${field.name}" but it already exists in the class.\n'
-              + 'Add @:blacklistOverride or add it to the ignoreList to ignore.',
-              Context.currentPos());
+              + 'Add @:blacklistOverride or add it to "ignoreList" to ignore.',
+              getField(field.name).pos);
           }
           continue;
         }
 
         final blacklisted:Bool = params.whitelistMode != params.fieldList.contains(field.name);
-        final wrapper:Null<Field> = generateWrapperFunction(field.name, extractField(field), c.name, blacklisted);
+        final wrapper:Null<Field> = generateWrapperField(field.name, field, c.name, blacklisted);
         generatedFields.push(wrapper);
 
         // TODO: When this happens should it make the field whitelisted (or vice-versa)?
-        if (fieldsToWrap.contains(field.name))
+        if (pendingFieldsToWrap.contains(field.name))
         {
           for (alias in aliases.get(field.name))
           {
-            generatedFields.push(generateWrapperFunction(alias, wrapper));
-            fieldsToWrap.remove(field.name);
+            generatedFields.push(generateWrapperField(alias, wrapper));
+            pendingFieldsToWrap.remove(field.name);
           }
         }
       }
     }
 
-    for (f in fieldsToWrap)
+    for (f in pendingFieldsToWrap)
     {
       Context.reportError('Tried to generate alias fields for "$f" but it does not exist.', Context.currentPos());
     }
 
     return buildFields.concat(generatedFields);
   }
 
-  static function generateWrapperFunction(funcName:String, wrappedField:Field, ?className:String, blacklist:Bool = false):Null<Field>
+  static function generateWrapperField(fieldName:String, wrappedField:Either<Field, ClassField>, ?className:String, blacklist:Bool = false):Null<Field>
   {
-    var kind = switch (wrappedField.kind)
-    {
-      case FFun(f):
-        final wrapFunc:Function = Reflect.copy(f);
-        final params:Array<Expr> = [for (a in wrapFunc.args) macro $i{a.name}];
+    final pack:Array<String> = [wrappedField.name];
+    if (className != null) pack.unshift(className);
 
-        final pack = [wrappedField.name];
-        if (className != null) pack.unshift(className);
-
-        wrapFunc.expr = if (blacklist)
-        {
-          macro throw $v{'Function ${pack.join('.')} is blacklisted.'};
-        }
-        else
-        {
-          returnsVoid(wrapFunc.ret) ? macro $p{pack}($a{params}) : macro return $p{pack}($a{params});
-        }
-        FFun(wrapFunc);
-      default:
-        return null;
+    inline function getWrapperExpr(args:Array<{name:String}>, ?retType:ComplexType):Expr
+    {
+      return if (blacklist)
+      {
+        macro throw $v{'Function ${pack.join('.')} is blacklisted.'};
+      }
+      else
+      {
+        final params:Array<Expr> = [for (a in args) macro $i{a.name}];
+        retType.toString() == 'StdTypes.Void' ? macro $p{pack}($a{params}) : macro return $p{pack}($a{params});
+      }
     }
 
-    return {
-      name: funcName,
-      pos: wrappedField.pos,
-      doc: blacklist ? BLACKLISTED_FUNCTION_DOC : wrappedField.doc,
-      access: [APublic, AInline, AStatic],
-      kind: kind
-    };
-  }
-
-  /**
-   * Generates a dummy version of a function field. Only used to retrieve its argument data.
-   * @param field The `ClassField` to "clone" into a `Field`.
-   * @return May return null if it's not a function.
-   */
-  static function extractField(field:ClassField):Null<Field>
-  {
-    var success:Bool = false;
-    final fieldFunc:Function = {args: [], params: getParamDecls(field.params), expr: macro null}
-    final tExpr:Null<TypedExpr> = field.expr();
-    if (tExpr == null)
+    var wrapperKind:Null<FieldType>;
+    if (wrappedField.kind is FieldType)
     {
-      // Field may be extern
-      switch (field.type.followWithAbstracts())
+      var wrappedField:Field = wrappedField;
+      wrapperKind = switch (wrappedField.kind)
       {
-        case TFun(args, ret):
-          fieldFunc.args = [for (a in args) {name: a.name, opt: a.opt, type: a.t.toComplexType()}];
-          fieldFunc.ret = ret.toComplexType();
-          success = true;
+        case FFun(f):
+          final wrapFunc:Function = Reflect.copy(f);
+          wrapFunc.expr = getWrapperExpr(wrapFunc.args, wrapFunc.ret);
+          FFun(wrapFunc);
         default:
+          Context.error('Blacklist Macro: Making aliases for anything other than functions is not supported.', wrappedField.pos);
       }
     }
     else
     {
-      switch (tExpr.expr)
+      var wrappedField:ClassField = wrappedField;
+      switch (wrappedField.kind)
       {
-        case TFunction(tfunc):
-          final tArgs:Array<FunctionArg> = [
-            for (a in tfunc.args)
-              {
-                name: a.v.name,
-                meta: a.v.meta?.get(),
-                value: a.value != null ? Context.getTypedExpr(a.value) : null,
-                type: a.v.t.toComplexType()
-              }
-          ];
-          fieldFunc.args = tArgs;
-          fieldFunc.ret = tfunc.t.toComplexType();
-          success = true;
+        case FVar(_, _):
+          wrapperKind = FProp('default', 'never', wrappedField.type.toComplexType(), macro $p{pack});
         default:
       }
+
+      if (wrapperKind == null)
+      {
+        if (wrappedField.expr() != null)
+        {
+          switch (wrappedField.expr().expr)
+          {
+            case TFunction(tfunc):
+              final args:Array<FunctionArg> = [
+                for (a in tfunc.args)
+                  {
+                    name: a.v.name,
+                    value: a.value != null ? Context.getTypedExpr(a.value) : null,
+                    type: a.v.t.toComplexType()
+                  }
+              ];
+              wrapperKind = FFun(
+                {
+                  args: args,
+                  params: getParamDecls(wrappedField.params),
+                  ret: tfunc.t.toComplexType(),
+                  expr: getWrapperExpr(args, tfunc.t.toComplexType()),
+                });
+            default:
+          }
+        }
+        else
+        {
+          // Some targets have core types with externs as fields and those don't have a TypedExpr.
+          switch (wrappedField.type.follow(true))
+          {
+            case TFun(args, ret):
+              wrapperKind = FFun(
+                {
+                  args: [for (a in args) {name: a.name, opt: a.opt, type: a.t.toComplexType()}],
+                  params: getParamDecls(wrappedField.params),
+                  ret: ret.toComplexType(),
+                  expr: getWrapperExpr(args, ret.toComplexType())
+                });
+            default:
+          }
+        }
+
+        if (wrapperKind == null)
+        {
+          Context.error('Blacklist Macro: Invalid field type, it should be a variable or a function.', wrappedField.pos);
+        }
+      }
     }
 
-    if (!success)
+    final access = [APublic, AStatic];
+    if (wrapperKind.match(FFun(_)))
     {
-      Context.error('Attempted to convert "${field.name} but it is not a function.', Context.currentPos());
+      access.push(AInline);
     }
 
     return {
-      name: field.name,
-      access: [APublic, AStatic, AInline],
-      doc: field.doc,
-      pos: field.pos,
-      kind: FFun(fieldFunc)
-    }
-  }
-
-  static inline function containsField(fields:Array<Field>, fieldName:String):Bool
-  {
-    return fields.exists(f -> f.name == fieldName);
-  }
-
-  static inline function getField(fields:Array<Field>, fieldName:String):Null<Field>
-  {
-    return fields.find(f -> f.name == fieldName);
+      name: fieldName,
+      pos: wrappedField.pos,
+      doc: blacklist ? BLACKLISTED_FUNCTION_DOC : wrappedField.doc,
+      access: access,
+      kind: wrapperKind
+    };
   }
 
   static function getParamDecls(params:Array<TypeParameter>):Array<TypeParamDecl>
   {
     final result:Array<TypeParamDecl> = [];
     for (p in params)
     {
-      switch (p.t)
+      switch (p.t.getClass()?.kind)
       {
-        case TInst(_.get() => cls, _):
-          switch (cls.kind)
-          {
-            case KTypeParameter(constraints):
-              result.push({name: p.name, constraints: [for (c in constraints) c.toComplexType()]});
-            default:
-              Context.error("Provided type parameters are not of the KTypeParameter kind, this shouldn't happen!", Context.currentPos());
-          }
+        case KTypeParameter(constraints):
+          result.push({name: p.name, constraints: [for (c in constraints) c.toComplexType()]});
         default:
-          Context.error("Provided type parameters are not of a class type.", Context.currentPos());
+          Context.error("Provided type parameters are not of the KTypeParameter kind, this shouldn't happen!", Context.currentPos());
       }
     }
     return result;
   }
-
-  static function returnsVoid(?ct:ComplexType):Bool
-  {
-    if (ct == null) return true;
-    return switch (ct)
-    {
-      case TPath(p): p.name == 'Void';
-      default: false;
-    }
-  }
 }
 #end
