Boolean assignment optimized by compiler

In a slightly smaller version, the issue is reproducible in the code below too:

class Rule {
   Boolean X,Y,Z
   def rules = {
      X = [Y, Z]
    }
   void setProperty(String n, v) {
       println "n = $n, v = $v" // prints n = X, v = true
   }
}

new Rule().rules()

setProperty should get the list. But the setter for X should do the type conversion... well, the meta class, that calls the setter should do that.

So, as a general rule, type conversion should be removed from compiler - for assignments? To change it from compile-time wiring to run-time handling (through meta-classes)? Or, am I not following you?

no, there is also field=foo, in that case the compiler usually generates code, that will directly set the field, in which case the conversion has to be done by the compiler too

After looking at this again my last comment actually makes no sense. It is true that for code in a class we don't go trough setProperty and thus the compiler has to do those things. But here it is code from a closure and that code indeed goes through the setProperty call.

To have the compiler base transformations and the ones done for direct field access it would actually be good to always let the compiler do that. But then the compiler needs to know the type and if it is not X=, but foo.X=, then it is most probably not the case and the setter code will have to do the conversion anyway.

So I think setProperty should get the list in that case.

I didn't check since when exactly this issue has been fixed, but it seems that current Groovy does not longer show this behaviour. Thus I close the issue as fixed