You can write Lisp in any language.

lispy_AST_transform.groovy

def loadMethod = ZweigBuilder.toNode([
        method:     "load",
        modifier:   ["public", "static"],
        returnType: ClassHelper.VOID_TYPE,
        body: [
                [if:   [not: flagField],
                 then: [on: mutexField,
                        synchronize: [
                                [if:   [not: flagField],
                                 then: [do: [
                                         [callStatic: methodNode.name,
                                          on:         extensionClass],
                                         [set: flagField,
                                          to:  true]]]]]]]
        ]
])

ugly_AST_transform.groovy

def loadMethod = new MethodNode(
        "load",
        Modifier.PUBLIC | Modifier.STATIC,
        ClassHelper.VOID_TYPE,
        [] as Parameter[],
        [] as ClassNode[],
        new BlockStatement(
                [new IfStatement(
                        new NotExpression(new FieldExpression(flagField)),
                        new SynchronizedStatement(
                                new FieldExpression(mutexField),
                                new BlockStatement(
                                        [new IfStatement(
                                                new NotExpression(new FieldExpression(flagField)),
                                                new BlockStatement(
                                                        [new ExpressionStatement(
                                                                new StaticMethodCallExpression(
                                                                        extensionClass,
                                                                        methodNode.name,
                                                                        ArgumentListExpression.EMPTY_ARGUMENTS
                                                                )
                                                        ),
                                                        new ExpressionStatement(
                                                                new BinaryExpression(
                                                                        new FieldExpression(flagField),
                                                                        new Token(Types.ASSIGN, "=", -1, -1),
                                                                        new ConstantExpression(true)
                                                                )
                                                        )] as Statement[],
                                                        new VariableScope()
                                                ),
                                                EmptyStatement.INSTANCE
                                        )] as Statement[],
                                        new VariableScope()
                                )
                        ),
                        EmptyStatement.INSTANCE
                )] as Statement[],
                new VariableScope()
        )
)