Groovy 2 update

Greach, Madrid, Spain

Cédric Champeau, SpringSource

Jan 2013 25th

About me

Past : Groovy contributor

Bugfixes
Modules: @Bytecode AST xform, GFreeMarker
Core: compilation customizers, @xInterrupt, ...
Used Groovy as a DSL for natural language processing

Present: Core Groovy committer

Working on bugfixes but main focus on Groovy 2.0
Static type checking
Static compilation

Follow me

Before we start...

A little surprise...

About Groovy

1.7M downloads in 2012!
Someone wants to talk to you...

Groovy 2

Modularity

Groovy’s « all » JAR weighs in at 6 MB
Nobody needs everything
Provide a smaller core
- Template engine, Ant scripting, Swing UI building...
Provide hooks for setting up DGM methods, etc.
- and several smaller JARs per feature

The new JARs

A smaller JAR: 3MB
Modules

Extension modules

idea: bring StringUtils as a first-class citizen
provide your own extensions to the GDK
call them from Groovy code

package foo

class StringExtension {
    static String shift(String self, int nb) {
      int len =self.length()
      def sb = new StringBuilder(len)
      len.times { i ->
        sb.append(self[(i+nb)%len])
      }
      sb
    }
}
// usage: assert 'foo'.shift(1) == 'oof'

Extension modules

Support for static methods too

package foo

class StaticStringExtension {
    static void hi(String self) {
      println 'Hi!'
    }
}
// usage: String.hi()

Extension module descriptor

Descriptor in: META-INF/services/org.codehaus.groovy.runtime.ExtensionModule

moduleName = stringExtensions
moduleVersion = 1.0
// comma-separated list of classes
extensionClasses = foo.StringExtension
// comma-separated list of classes
staticExtensionClasses = foo.StaticStringExtension

Real-life example: Tim Yate's
- Lazy Streams
- Common Extensions

Groovy 2

JDK 7 enhancements

JDK 7 enhancements: Binary literals

We had decimal, octal and hexadecimal notations for number literals
We can now use binary representations too

int x = 0b10101111
assert x == 175
 
byte aByte = 0b00100001
assert aByte == 33
 
int anInt = 0b1010000101000101
assert anInt == 41285

JDK 7 enhancements: Underscores in literals

Now we can also add underscores in number literals for more readability

long creditCardNumber = 1234_5678_9012_3456L
long socialSecurityNumbers = 999_99_9999L
float monetaryAmount = 12_345_132.12
long hexBytes = 0xFF_EC_DE_5E
long hexWords = 0xFFEC_DE5E
long maxLong = 0x7fff_ffff_ffff_ffffL
long alsoMaxLong = 9_223_372_036_854_775_807L
long bytes = 0b11010010_01101001_10010100_10010010

JDK 7 enhancements: Multicatch

One block for multiple exception caught

try {
    /* ... */
} catch(IOException | NullPointerException e) {
    /* one block to treat 2 exceptions */
}

Groovy 2

InvokeDynamic support

InvokeDynamic

Groovy 2.0 supports JDK 7’s invokeDynamic
- compiler has a flag for compiling against JDK 7
- might use the invokeDynamic backport for < JDK 7
Benefits
- more runtime performance!
- at least as fast as current « dynamic » Groovy
in the long run, will allow us to get rid of code!
- call site caching, thanks to MethodHandles
- metaclass registry, thanks to ClassValues
- will let the JIT inline calls more easily

Groovy 2

Static type checking

Goal

Find errors at compile time (fail early)
because lots of code do not use dynamic features of Groovy
so many bugs can be discovered before production
Make java developers even happier

Turn the compiler grumpy

Report typos
missing method/property
Extension methods (aka DefaultGroovyMethods)
Type check assignments
Perform type inference
method/closure return type inference
generics type inference

Static type checking: typos

import groovy.transform.TypeChecked
 
void method() {}
 
@TypeChecked test() {
    // Cannot find matching method metthhoood()
    metthhoood()
 
    def name = "Guillermo"
    // variable naamme is undeclared
    println naamme
}

Type checking options

if set on a class, type checks:

the whole class
inner classes
closures defined in the class

if set on a method, type checks:

the method only
closures defined in the method body

You can prevent some code from beeing type checked:

import groovy.transform.TypeChecked
import static groovy.transform.TypeCheckingMode.*

@TypeChecked(SKIP)
int foo() { 'STRING SHOULD NOT PASS TYPE CHECKING' }

Static type checking: assignments

// cannot assign value of type... to variable...
int x = new Object()
Set set = new Object()
 
def o = new Object()
int x = o
 
String[] strings = ['a','b','c']
int str = strings[0]
 
// cannot find matching method plus()
int i = 0
i += '1'

Static type checking: return types

// checks if/else branch return values
@TypeChecked
int method() {
    if (true) { 'String' }
    else { 42 }
}
// works for switch/case & try/catch/finally
 
// transparent toString() implied
@TypeChecked
String greeting(String name) {
    def sb = new StringBuilder()
    sb << "Hi " << name
}

Static type checking: type inference

@TypeChecked test() {
    def name = "  Guillaume  "
 
    // String type infered (even inside GString)
    println "NAME = ${name.toUpperCase()}"
 
    // Groovy GDK method support
    // (GDK operator overloading too)
    println name.trim()
 
    int[] numbers = [1, 2, 3]
    // Element n is an int
    for (int n in numbers) {
        println n
    }
}

Static type checking: mixing static and dynamic

@TypeChecked
String greeting(String name) {
    // call method with dynamic behavior
    // but with proper signature
    generateMarkup(name.toUpperCase())
}
 
// usual dynamic behavior
String generateMarkup(String name) {
    def sw = new StringWriter()
    new MarkupBuilder(sw).html {
        body {
            div name
        }
    }
    sw.toString()
}

Static type checking: instanceof

@TypeChecked
void test(Object val) {

    if (val instanceof String) {
        println val.toUpperCase()
    } else if (val instanceof Number) {
        println "X" * val.intValue()
    }
}

Static type checking: lowest upper bound

Represents a "common super type" that may not exist as a real class/interface

@TypeChecked test() {
    // an integer and a BigDecimal
    return [1234, 3.14]
}

List<Comparable & Serializable>

Static type checking: flow typing

Static type checking shouldn’t complain even for bad coding practicies which work without type checks

@TypeChecked test() {
    def var = 123         // inferred type is int
    int x = var           // var is an int
    var = "123"           // assign var with a String

    x = var.toInteger()   // no problem, no need to cast

    var = 123
    x = var.toUpperCase() // error, var is int!
}

STC gotchas: dynamic vs static

Type checking works at compile-time
- adding @TypeChecked doesn’t change behavior
- do not confuse with static compilation
Most dynamic features cannot be type checked
- metaclass changes, categories
- dynamically bound variables (ex: script’s binding)
But compile-time metaprogramming works
- as long as proper type information is defined

STC gotchas: closure argument types

@TypeChecked test() {
    ["a", "b", "c"].collect { String it -> // you need to declare the type
        it.toUpperCase()
    }
}

Type descriptors not sufficient to describe closure arguments
Enhancement should be proposed for Groovy 2.2

STC gotchas: closure shared variables 1/2

in general, you cannot know when a closure will be called
only method calls on LUB should be allowed

@TypeChecked test() {
    def var = "abc"
    def cl = { var = new Date() }
    if (random) cl()
    var.toUpperCase()  // Not OK!
}

STC gotchas: closure shared variables 2/2

in general, you cannot know when a closure will be called
only method calls on LUB should be allowed

class A           { void foo() {} }
class B extends A { void bar() {} }

@TypeChecked test() {
    def var = new A()
    def cl = { var = new B() }
    if (random) cl()
    var.foo()   // OK!
}

Groovy 2

Static compilation

Given your Groovy code can be type checked...
- we can as well compile it « statically »
- ie. generate the same byte code as javac
Also interesting for those stuck in JDK < 7
- to benefit from performance improvements

Only change required: @TypeChecked to @CompileStatic

Static compilation: pros

You gain

Type safety
- thanks to static type checking
- static compilation builds upon static type checking
Faster code
- as close as possible to Java’s performance
- Code immune to « monkey patching »
- metaprogramming badly used can interfere with framework code
- Smaller bytecode size

Static compilation: cons

But you loose

Dynamic features
- metaclass changes, categories, etc.
Dynamic method dispatch

Groovy 2.1

Full InvokeDynamic support

In Groovy 2.0, not all call paths
- were going through invoke dynamic calls
- essentially method calls only
- still used call site caching techniques
On JDK 7 with the « indy » JAR, Groovy 2.1 uses invoke dynamic everywhere
On JDK < 7, still uses call site caching

Groovy 2.1

@DelegatesTo

Static type checking works nicely for certain Domain-Specific Languages
- command chains, extension methods, etc.

But for changes of delegation within closures, it’s not helping
- often used by DSLs like within Gradle
- also interesting for IDE/documentation

Enters @DelegatesTo!

@DelegatesTo

Define a class that has a foo() method

class ExecSpec {
    void foo()
}

Define a with method that does a "reversed with"

void with(ExecSpec sp, Closure c) {
    c.delegate = sp
    c()
}

Use it

with(spec) {
    foo() // how do we know this is valid?
}

Will IDE know about foo()? Would the type checker know?

@DelegatesTo

Solution
- Annotate with @DelegatesTo
- Specify the delegate type as argument

void with(ExecSpec sp, @DelegatesTo(ExecSpec) Closure c) {
    c.delegate = sp
    c()
}

@DelegatesTo

Solution 2
- Annotate with @DelegatesTo
- Set the delegation target

void with(@DelegatesTo.Target ExecSpec sp, @DelegatesTo Closure c) {
    c.delegate = sp
    c()
}

@DelegatesTo: advantages

For DSLs using Groovy closure delegation
Great for...
- documenting APIs
- IDE integration
  - code completion, code navigation...
working nicely with static type checking and static compilation
See more tomorrow! (10:15, Type checking your DSLs)

Groovy 2.1

@Alias

Alias annotations

Tired of annotation hell?
Want to create custom annotation combining others?
Still want to be able to change parameters?

Alias annotations

The verbose declaration

boolean create(@NotNull @NotBlank @Regex('...') String email) { ... }

Define an alias

    @NotNull
    @NotBlank
    @Regex
    @AnnotationCollector
    @interface Email {}

Use it!

boolean create(@Email('...') String email) { ... }

Alias annotations

Replaces alias with target annotations at compile time
Alias is not visible anymore at runtime
Ability to create custom "expanders" for complex aliases

As an example, Groovy 2.1 includes @CompileDynamic as an alias for @CompileStatic(TypeCheckingMode.SKIP)

Groovy 2.1

Compilation configuration

Taking control of your Groovy

Groovy 1.8 introduced compilation customizers
- add imports, AST xforms, secure the AST...
With static type checking and static compilation, we received feedback from people wanting them applied « by default »
Make available to groovyc what was available to GroovyShell or GroovyScriptEngine
- with a configuration script
- groovyc -configurator compConf.groovy Foo.groovy

Compilation configuration script

The configuration script gives you access to CompilerConfiguration

withConfig(configuration) {
    source(basenameValidator: { it.endsWith('MyDomain') }) {
        ast(ToString)
    }
    source(basenameValidator: { it.endsWith('mathFormula') }) {
        imports {
            staticStar 'java.lang.Math'
        }
    }
}

The CompilationCustomizerBuilder is available outside of this context

Groovy 2.1

Type checking extensions

Plug into the type checking system
Very interesting for DSLs
Make the compiler smarter!

Extensive description tomorrow, "Type checking your DSLs" at 10:15

Type checking extensions: example

Take this code

    point a
    point b
    line (b,c)
    line (a,b)
    point c

Can you make it pass type checking?
- Ensure that "b" is a point in line(b,c)
- Handle forward references
Hint: answer is yes!

Type checking extensions

Makes use of an event-based API
- ex: onMethodSelection, unresolvedVariable, ...
Allows you to make the compiler even smarter than Java is!

@TypeChecked('MyExtension.groovy')
def myMethod() {
 //
}

Groovy 2 update

Greach, Madrid, Spain

Cédric Champeau, SpringSource

Jan 2013 25th

About me

Past : Groovy contributor

Present: Core Groovy committer

Follow me

Before we start...

A little surprise...

About Groovy

Groovy 2

Modularity

Modularity

The new JARs

Extension modules

Extension modules

Extension module descriptor

Groovy 2

JDK 7 enhancements

JDK 7 enhancements: Binary literals

JDK 7 enhancements: Underscores in literals

JDK 7 enhancements: Multicatch

Groovy 2

InvokeDynamic support

InvokeDynamic

Groovy 2

Static type checking

Static type checking

Goal

Turn the compiler grumpy

Static type checking: typos

Type checking options

if set on a class, type checks:

if set on a method, type checks:

Static type checking: assignments

Static type checking: return types

Static type checking: type inference

Static type checking: mixing static and dynamic

Static type checking: instanceof

Static type checking: lowest upper bound

Static type checking: flow typing

STC gotchas: dynamic vs static

STC gotchas: closure argument types

STC gotchas: closure shared variables 1/2

STC gotchas: closure shared variables 2/2

Groovy 2

Static compilation

Static compilation

Static compilation: pros

Static compilation: cons

Groovy 2.1

Full InvokeDynamic support

Groovy 2.1

@DelegatesTo

@DelegatesTo

@DelegatesTo

@DelegatesTo

@DelegatesTo

@DelegatesTo: advantages

Groovy 2.1

@Alias

Alias annotations

Alias annotations

Alias annotations

Groovy 2.1

Compilation configuration

Taking control of your Groovy

Compilation configuration script

Groovy 2.1

Type checking extensions

Type checking extensions

Type checking extensions: example

Type checking extensions

Questions

Thank you!