14.1 The GrailsCompileStatic Annotation

GrailsCompileStatic

The GrailsCompileStatic annotation may be applied to a class or methods within a class.

import grails.compiler.GrailsCompileStatic
@GrailsCompileStatic
class SomeClass {
    // all of the code in this class will be statically compiled
    def methodOne() {
        // ...
    }
    def methodTwo() {
        // ...
    }
    def methodThree() {
        // ...
    }
}

import grails.compiler.GrailsCompileStatic
class SomeClass {
    // methodOne and methodThree will be statically compiled
    // methodTwo will be dynamically compiled
    @GrailsCompileStatic
    def methodOne() {
        // ...
    }
    def methodTwo() {
        // ...
    }
    @GrailsCompileStatic
    def methodThree() {
        // ...
    }
}

It is possible to mark a class with GrailsCompileStatic and exclude specific methods by marking them with GrailsCompileStatic and specifying that the type checking should be skipped for that particular method as shown below.

import grails.compiler.GrailsCompileStatic
import groovy.transform.TypeCheckingMode
@GrailsCompileStatic
class SomeClass {
    // methodOne and methodThree will be statically compiled
    // methodTwo will be dynamically compiled
    def methodOne() {
        // ...
    }
    @GrailsCompileStatic(TypeCheckingMode.SKIP)
    def methodTwo() {
        // ...
    }
    def methodThree() {
        // ...
    }
}

Code that is marked with GrailsCompileStatic will all be statically compiled except for Grails specific interactions that cannot be statically compiled but that GrailsCompileStatic can identify as permissible for dynamic dispatch. These include things like invoking dynamic finders and DSL code in configuration blocks like constraints and mapping closures in domain classes.

Care must be taken when deciding to statically compile code. There are benefits associated with static compilation but in order to take advantage of those benefits you are giving up the power and flexibility of dynamic dispatch. For example if code is statically compiled it cannot take advantage of runtime metaprogramming enhancements which may be provided by plugins.