是否可以使用 haxe 宏来检测对象何时变脏（任何属性已更改）

Question

Let say we have an object:

@:checkDirty
class Test {
   var a:Int;
   var b(default, default):String;
   var c(get, set):Array<Int>;

   public function new() {
     ...
   }
   public function get_c() {
      ...
   }
   public function set_c(n) {
     ... 
   }


}

Could we write a macro checkDirty so that any change to field/properties would set property dirty to true . Macro would generate dirty field as Bool and clearDirty function to set it to false .

var test = new Test();
trace(test.dirty); // false
test.a = 12;
trace(test.dirty); // true
test.clearDirty();
trace(test.dirty); //false
test.b = "test"
trace(test.dirty); //true

test.clearDirty();
test.c = [1,2,3];
trace(test.dirty); //true

Answer 1

Just to note - whenever you consider proxying access to an object, in my experience, there are always hidden costs / added complexity. :)

That said, you have a few approaches:

First, if you want it to be pure Haxe, then either a macro or an abstract can get the job done. Either way, you're effectively transforming every property access into a function call that sets the value and also sets dirty .

For example, an abstract using the @:resolve getter and setter can be found in the NME source code , replicated here for convenience:

@:forward(decode,toString)
abstract URLVariables(URLVariablesBase)
{
   public function new(?inEncoded:String)
   {
      this = new URLVariablesBase(inEncoded);
   }
   @:resolve
   public function set(name:String, value:String) : String
   {
      return this.set(name,value);
   }

   @:resolve
   public function get(name:String):String
   {
      return this.get(name);
   }
}

This may be an older syntax, I'm not sure... also look at the operator overloading examples on the Haxe manual:

  @:op(a.b) public function fieldRead(name:String)
    return this.indexOf(name);

  @:op(a.b) public function fieldWrite(name:String, value:String)
    return this.split(name).join(value);

Second, I'd just point out that if the underlying language / runtime supports some kind of Proxy object (eg JavaScript Proxy ), and macro / abstract isn't working as expected, then you could build your functionality on top of that.

Answer 2

I wrote a post ( archive ) about doing this kind of thing (except for emitting events) before - you can use a @:build macro to modify class members, be it appending an extra assignment into setter or replacing the field with a property.

So a modified version might look like so:

class Macro {
    public static macro function build():Array<Field> {
        var fields = Context.getBuildFields();
        for (field in fields.copy()) { // (copy fields so that we don't go over freshly added ones)
            switch (field.kind) {
                case FVar(fieldType, fieldExpr), FProp("default", "default", fieldType, fieldExpr):
                    var fieldName = field.name;
                    if (fieldName == "dirty") continue;
                    var setterName = "set_" + fieldName;
                    var tmp_class = macro class {
                        public var $fieldName(default, set):$fieldType = $fieldExpr;
                        public function $setterName(v:$fieldType):$fieldType {
                            $i{fieldName} = v;
                            this.dirty = true;
                            return v;
                        }
                    };
                    for (mcf in tmp_class.fields) fields.push(mcf);
                    fields.remove(field);
                case FProp(_, "set", t, e):
                    var setter = Lambda.find(fields, (f) -> f.name == "set_" + field.name);
                    if (setter == null) continue;
                    switch (setter.kind) {
                        case FFun(f):
                            f.expr = macro { dirty = true; ${f.expr}; };
                        default:
                    }
                default:
            }
        }
        if (Lambda.find(fields, (f) -> f.name == "dirty") == null) fields.push((macro class {
            public var dirty:Bool = false;
        }).fields[0]);
        return fields;
    }
}

which, if used as

@:build(Macro.build())
@:keep class Some {
    public function new() {}
    public var one:Int;
    public var two(default, set):String;
    function set_two(v:String):String {
        two = v;
        return v;
    }
}

Would emit the following JS:

var Some = function() {
    this.dirty = false;
};
Some.prototype = {
    set_two: function(v) {
        this.dirty = true;
        this.two = v;
        return v;
    }
    ,set_one: function(v) {
        this.one = v;
        this.dirty = true;
        return v;
    }
};