WIP on property overrides

Author: NotHyper-474

source/funkin/util/ReflectUtil.hx

@@ -18,9 +18,10 @@ package funkin.util;
         "hasField": ["hasAnonymousField"],
         "setField": ["setAnonymousField"]
       },
-    fieldList: [
+    customWrapList: [
       "compare",
       "compareMethods",
+      "copy",
       "enumEq",
       "deleteField",
       "fields",

source/funkin/util/macro/BlacklistClassMacro.hx

@@ -12,7 +12,11 @@ using haxe.macro.ComplexTypeTools;
 using Lambda;
 using StringTools;
 
-typedef Either<T, V> = Dynamic;
+enum abstract WrapMode(String) from String to String
+{
+  var Blacklist;
+  var Whitelist;
+}
 
 typedef WrapperParams =
 {
@@ -22,37 +26,40 @@ typedef WrapperParams =
   var classes:Array<String>;
 
   /**
-   * Aliases to functions, for instance `{ "getAnonymousField": ["field"]] }` generates a `field` function that calls `getAnonymousField`.
+   * Aliases to functions, for instance `{ "getAnonymousField": ["field"] }` generates a `field` function that calls `getAnonymousField`.
    * It works in both ways, so you can generate aliases in the class that point to the ones in `classes` and vice-versa.
-   * This should be strictly structured as { fieldName: Array<String> }, failure to comply will result in undefined behaviour.
+   * This should be strictly structured as `{ fieldName: Array<String> }`, failure to comply will result in undefined behaviour.
    */
   var ?aliases:{};
 
   /**
-   * Functions that should be wrapped based on `whitelistMode`.
+   * Functions that should be wrapped based on `wrapMode`.
    * If a function is part of an alias or the ignore list, this will have no effect on it.
    */
-  var ?fieldList:Array<String>;
+  var ?customWrapList:Array<String>;
 
   /**
-   * Defines how fields in `fieldList` are wrapped.
-   * By default it's `true`, which means fields outside the list are blacklisted by default.
+   * Defines how fields in `customWrapList` are wrapped.
+   * If it's `Whitelist` fields outside the list are blacklisted by default.
+   *
+   * @default `Whitelist`
    */
-  var ?whitelistMode:Bool;
+  var ?customWrapMode:WrapMode;
 
   /**
-   * Functions in the provided classes that the macro should skip generating.
+   * Functions in `classes` that the macro should not generate.
    * If a function is part of an alias, this will have no effect on it.
    */
   var ?ignoreList:Array<String>;
 }
 
 /**
  * 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.
+ * they'll throw an error if accessed, or call the original function if whitelisted.
  * 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`).
+ * Note that if the field already exists in `BlacklistParams.classes` you should add `@:blacklistOverride` to it.
  */
 class BlacklistClassMacro
 {
@@ -61,69 +68,45 @@ class BlacklistClassMacro
    */
   static final BLACKLISTED_FUNCTION_DOC:String = "This function is not allowed to be used by scripts.\n@throws error When called by a script.";
 
-  static function build(params:WrapperParams):Array<Field>
+  static var buildFields:Array<Field>;
+  static var processedFieldNames:Array<String> = [];
+
+  static inline function containsField(fieldName:String):Bool
   {
-    params.whitelistMode ??= true;
-    params.fieldList ??= [];
+    return buildFields.exists(f -> f.name == fieldName);
+  }
 
+  static inline function getField(fieldName:String):Null<Field>
+  {
+    return buildFields.find(f -> f.name == fieldName);
+  }
+
+  static function build(params:WrapperParams):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());
 
-    final buildFields:Array<Field> = Context.getBuildFields();
-    final generatedFields:Array<Field> = [];
+    buildFields = Context.getBuildFields();
+    var generatedFields:Array<Field> = [];
 
-    // 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);
-    }
+    params.customWrapList ??= [];
+    params.customWrapMode ??= Whitelist;
 
     // 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 fieldsToSkip:Array<String> = params.ignoreList?.copy() ?? [];
-    final pendingFieldsToWrap:Array<String> = [];
+    var fieldsToSkip:Array<String> = params.ignoreList?.copy() ?? [];
+    var 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(field);
-        if (wrappedField == null)
-        {
-          // Field might be on the provided classes, put it on queue.
-          pendingFieldsToWrap.push(field);
-          continue;
-        }
-
-        for (aliasName in aliasFields)
-        {
-          if (containsField(aliasName))
-          {
-            Context.error('Tried to generate "${aliasName}" alias but it already exists in the class.', getField(aliasName).pos);
-          }
-
-          final wrapper:Null<Field> = generateWrapperField(aliasName, wrappedField);
-          if (wrapper != null)
-          {
-            generatedFields.push(wrapper);
-            fieldsToSkip.push(aliasName);
-          }
-          else
-            Context.error('Could not generate alias for field "$field"; it may not be a function.', wrappedField.pos);
-        }
-      }
+      generatedFields = generateAliases(aliases, pendingFieldsToWrap);
     }
 
     for (c in classes)
     {
       for (field in c.statics.get())
       {
-        if (!field.isPublic || fieldsToSkip.contains(field.name)) continue;
+        if (!field.isPublic || fieldsToSkip.contains(field.name) || ~/^(get|set)_/.match(field.name)) continue;
 
         if (containsField(field.name))
         {
@@ -136,8 +119,7 @@ class BlacklistClassMacro
           }
           continue;
         }
-
-        final blacklisted:Bool = params.whitelistMode != params.fieldList.contains(field.name);
+        final blacklisted:Bool = (params.customWrapMode == Whitelist) != params.customWrapList.contains(field.name);
         final wrapper:Null<Field> = generateWrapperField(field.name, field, c.name, blacklisted);
         generatedFields.push(wrapper);
 
@@ -161,12 +143,49 @@ class BlacklistClassMacro
     return buildFields.concat(generatedFields);
   }
 
-  static function generateWrapperField(fieldName:String, wrappedField:Either<Field, ClassField>, ?className:String, blacklist:Bool = false):Null<Field>
+  static function generateAliases(aliases:DynamicAccess<Array<String>>, ?unresolvedAliases:Array<String>):Array<Field>
+  {
+    var result:Array<Field> = [];
+
+    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(field);
+      if (wrappedField == null)
+      {
+        // Field might be on the provided classes, put it on queue.
+        unresolvedAliases.push(field);
+        continue;
+      }
+
+      for (aliasName in aliasFields)
+      {
+        if (containsField(aliasName))
+        {
+          Context.error('Tried to generate "${aliasName}" alias but it already exists in the class.', getField(aliasName).pos);
+        }
+
+        final wrapper:Null<Field> = generateWrapperField(aliasName, wrappedField);
+        if (wrapper != null)
+        {
+          result.push(wrapper);
+          processedFieldNames.push(aliasName);
+        }
+        else
+          Context.error('Could not generate alias for field "$field"; it may not be a function.', wrappedField.pos);
+      }
+    }
+
+    return result;
+  }
+
+  static function generateWrapperField(fieldName:String, wrappedField:Dynamic, ?className:String, blacklist:Bool = false):Null<Field>
   {
     final pack:Array<String> = [wrappedField.name];
     if (className != null) pack.unshift(className);
 
-    inline function getWrapperExpr(args:Array<{name:String}>, ?retType:ComplexType):Expr
+    function getWrapperExpr(args:Array<{name:String}>, ?retType:ComplexType):Expr
     {
       return if (blacklist)
       {
@@ -198,7 +217,8 @@ class BlacklistClassMacro
       var wrappedField:ClassField = wrappedField;
       switch (wrappedField.kind)
       {
-        case FVar(_, _):
+        case FVar(read, write):
+          trace(read, write);
           wrapperKind = FProp('default', 'never', wrappedField.type.toComplexType(), macro $p{pack});
         default:
       }