The meaning of the syntax x.y and &y have
changed slightly, in a way that will be transparent to most code.
In the past, if y was a local variable, then x.y
evaluated the local, then called the method on x specified
by the property pointer value in the local; &y simply
generated a compilation error because a local's address cannot be
evaluated. This behavior has changed. Now, x.y and
&y both ignore the local definition of y and
interpreter y as a property name. This change is important
because it allows code to refer to a property explicitly, even when
a local of the same name has been defined in the code block. For
example:
myObject: object
obj = nil
setObj(obj) { self.obj = obj; }
;
In the past, the code above would have had to use a different name
for the formal parameter variable obj, because it would not
have been able to refer to the property of the same name. With the
new interpretation, the code can distinguish between the local and
the property by referring to the property explicitly using self.obj.
Note that it is still simple to obtain the old behavior of
evaluating the local variable and calling a method via the resulting
property pointer. To do this, simply enclose the local in
parentheses: x.(y).