I made the very short walk from Hilton Plaza A/B back to Hilton Golden Gate 3/4/5 to see the presentation "Walk through Groovy's AST Transformations." Groovy's AST Transformations are something I've dabbled with directly a few times, but have more often benefited from others' work with them. I had started reading the Packt Publishing book Groovy for Domain-Specific Languages, but wanted to attend this presentation to reinvigorate my interest and kick-start my increased use of this powerful tool.
Andres Almiray (Canoo) presented this presentation on Groovy AST Transformations. It did not surprise me that most of the audience had Groovy experience given that use of Groovy ASTs is likely more appealing to those with some familiarity with Groovy already.
Almiray defined AST Transformations as "essentially byte code generation" that "enables compile-time metaprogramming." He showed that Groovy has two types of AST Transformations: global and local. The focus of today's presentation is on global AST transformations.
The AST Transformations framework was added to Groovy years ago, but things were made much easier in Groovy 1.7. Almiray covered the Delegate Transformation (
@Delegate annotation) in Groovy allows the compiled code to have all of the public methods of the field that was explicitly delegated to. Almiray explained that
@Delegate works with interfaces as well as classes. Almiray also explained that any new method defined will take precedent over any delgate method of the same signature. Similarly, the first delegate encountered takes precedent over same method signature of other delegates.
Almiray then covered
@Singleton and the Singleton Transformation. Almiray stated that the singleton implemented with this transformation meets the definition of a safe singleton described in Josh Bloch's Effective Java.
@Immutable (the Immutable Transformation) was covered next. Just as the
@Singleton transformation automatically implemented all necessary rules for singletons, the
@Immutable transformation implements the rules for immutable. Almiray noted that there are different exceptions for attempts to set a property on an immutable Groovy class via property set versus method set.
The next Groovy AST transformation to be covered was
@Category (the Category Transformation). This was the first covered transformation that requires usage within Groovy code (not within Java code) to be fully used. The Mixin Transformation (
@Mixin) was also covered.
Almiray moved onto coverage of
@Grab (Grab Transformation), one which I have posted about before.
@Grab is useful for downloading dependencies at runtime. I like it for the same reason that Almiray mentioned: "it's perfect for self-contained scripts."
Almiray introduced the
@Synchronized (Synchronized Transformation) as a Groovier way to specify synchronized blocks. Almiray covered the
@Lazy (Lazy Transformation), which is used to only initialize values when actually needed (when first used). Almiray pointed out Groovy's ability to access classes' private fields and cautioned that this should only be used for unit testing and only when absolutely necessary in production.
Almiray demonstrated use of
@Newify (Newify Transformation) before showing a code sample using
@Bindable (Bindable Transformation), which he stated was added to Groovy to make use of Swing easier. The transformation makes a class observable and removes the need to write all the code for explicitly doing this. The
@Vetoable transformation similarly makes it easier to veto a property change.
Almiray covered some of my favorite and most often-used Groovy transformations: @ToString (see my post), @EqualsAndHashCode (see my post), @TupleConstructor (see my post), or the combination of them all (@Canonical - see my post).
Following coverage of
@Canonical and its constituent transformations, Almiray moved onto covering
@IndexedProperty (related post). He then listed several others without code samples:
@ThreadInterrupt, @PackageScope ("gain back package-level access specificity in Groovy"),
@WithWriteLock, and @Field ("mostly used inside scripts").
I was happy to see Almiray mention the addition of @TypeChecked to support "static Groovy!" He referenced a later presentation on new features of Groovy 2.0 to get more details.
Although I was already familiar with a large percentage of the Groovy AST transformations covered in this presentation, it was still worthwhile to attend and learn of or be reminded of other useful transformations that are available.