implement getters/setters

The plan is to do this with rewriting.

Traits:

trait ... getter foo():T; end =>
trait ... g$foo():T; end

trait ... foo:T; end  =>
trait ... g$foo():T; end

trait ... hidden settable foo:T; end  =>
trait ... s$foo(t:T):(); end

trait ... setter foo(t:T):() end =>
trait ... s$foo(t:T):(); end

trait ... settable foo:T; end =>
trait ... s$foo(t:T):(); g$foo():T; end

trait ... setter foo(t:T):();  getter foo():T end  =>
trait ... s$foo(t:T):();            g$foo():T; end

Objects:

object ... getter foo():T = body; end =>
object ... g$foo():T = body; end

object ... foo:T=iv; end  =>
object ... g$foo():T = foo; foo:T=iv; end

object ... getter foo():T = body; foo:T=iv; end =>
object ... g$foo():T = body; foo:T=iv; end

object ... hidden settable foo:T=iv; end  =>
object ... s$foo(t:T):() = do foo := t end; foo:T=iv; end

object ... setter foo(t:T):() end  =>
object ... s$foo(t:T):(); end

object ... setter foo(t:T):(); foo:T=iv;  end  =>
object ... s$foo(t:T):(); foo:T=iv; end

object ... settable foo:T:=iv; end =>
object ... s$foo(t:T):(); g$foo():T; foo:T:=iv; end

object ... setter foo(t:T):(); getter foo():T end  =>
object ... s$foo(t:T):(); g$foo():T; end

object ... setter foo(t:T):(); getter foo():T; foo:T:=iv end  =>
object ... s$foo(t:T):(); g$foo():T; foo:T:=iv end

Gets. Lacking type info, for now we assume explicit parentheses to indicate invocation of an arrow-typed field.

 ... this.that ... => 
 ... this.g$that() ...
 
 ... this.that() ... => 
 ... this.that() ... (* method invocation *)

 (... this).that() ... => 
 (... g$this()).that() ... (* arrow-typed field *)

Sets

 this.that := x => 
 this.s$that(x)

Note, also, that there are rewritings in place that will change once proper type information and proper (dotted) import information is available.

See also #43, which ought to work when getters have been implemented.