Proposal request: explicit propreties

[Ary Borenszweig]

Currently properties can have these forms:

Getter:
-------
Type property() {
   // ...
}

Setter:
-------
void property(Type type) {
   // ...
}

The problem is, the user can use them as functions or as properties. 
This is ok from the compiler point of view, but the code looks ugly if 
it doesn't make sense, like:

writefln = 5;

Further, if you want a function to be only used with property syntax, 
you can't. Why would you wan't that? Because if you have

class Foo {

   int property() {
     //
   }

}

and then you decide to change it to

class Foo {

   int property;

}

for some reason, code that used Foo.property() won't compile anymore.

I suggest marking properties as such like this:

getter Type property() {
   // ...
}

setter void property() {
   // ...
}

"getter" and "setter" are attributes, just like "public", "static", etc. 
The compiler only uses them to validate correct syntax usage. If they 
are applied to any other declaration that is not a function, an error is 
reported.

Finally, there is another reason for wanting to mark functions as 
properties: when you do autocompletion in an IDE, and it suggests you a 
function, it can't know whether to autocomplete it as a function or as a 
property. A solution could be writing something in the ddoc of that 
function, but since there's no standard for this, each IDE will invent 
it's own.

Of course, this is not backwards compatible, so it should be a D2 feature.

What do you think?