4.2.1 Common accessor identifier combinations

The next example shows common access identifier combinations for properties:

class Main {
  // read from outside, write only within Main
  public var ro(default, null):Int;

  // write from outside, read only within Main
  public var wo(null, default):Int;

  // access through getter get_x and setter
  // set_x
  public var x(get, set):Int;

  // read access through getter, no write
  // access
  public var y(get, never):Int;

  // required by field x
  function get_x() return 1;

  // required by field x
  function set_x(x) return x;

  // required by field y
  function get_y() return 1;

  function new() {
    var v = x;
    x = 2;
    x += 1;
  }

  static public function main() {
    new Main();
  }
}

The JavaScript output helps understand what the field access in the main-method is compiled to:

var Main = function() {
    var v = this.get_x();
    this.set_x(2);
    var _g = this;
    _g.set_x(_g.get_x() + 1);
};

As specified, the read access generates a call to get_x(), while the write access generates a call to set_x(2) where 2 is the value being assigned to x. The way the += is being generated might look a little odd at first, but can easily be justified by the following example:

class Main {
  public var x(get, set):Int;

  function get_x() return 1;

  function set_x(x) return x;

  public function new() {}

  static public function main() {
    new Main().x += 1;
  }
}

What happens here is that the expression part of the field access to x in the main method is complex: It has potential side-effects, such as the construction of Main in this case. Thus, the compiler cannot generate the += operation as new Main().x = new Main().x + 1 and has to cache the complex expression in a local variable:

Main.main = function() {
    var _g = new Main();
    _g.set_x(_g.get_x() + 1);
}

---