您可以使用Groovy的GeneralUtils类中的静态方法来改进您的原始解决方案：

class GrantASTTransformation implements ASTTransformation {
    @Override
    void visit(ASTNode[] nodes, SourceUnit source ) {
        nodes?.find{ it in MethodNode }?.with{ augmentMethod it }
    }

    void augmentMethod( MethodNode mn ) {
        def annos = mn.getAnnotations new ClassNode( Grant )
        def rolesValue = annos.first().getMember 'value'
        def param = varX( mn.parameters[ 0 ] )

        def args = args( param, rolesValue )
        def callCheck = callX( new ClassNode( GrantUtil ), 'checkAuthorization', args )
        def notAuthorized = notX( boolX( callCheck ) )
        def returnEarly = returnS( nullX() )

        def guard = ifS( notAuthorized, returnEarly )
        mn.code.statements.add 0, guard
    }
}

至于AstBuilder，它现在不如它的替代品宏那么受欢迎。使用宏编写augmentMethod的一种方法是：

void augmentMethod( MethodNode mn ) {
    def grantNode = ClassHelper.make(Grant)
    def grantUtilNode = ClassHelper.make(GrantUtil)
    def annos = mn.getAnnotations grantNode
    def rolesValue = annos.first().getMember 'value'
    def param = varX( mn.parameters[ 0 ] )
    def guard = macro {
        if (!$v{ classX(grantUtilNode) }.checkAuthorization( $v{ param }, $v{ rolesValue } )) {
            return
        }
    }
    mn.code.statements.add 0, guard
}

你只需要小心在代码中引用类，这就是为什么GrantUtil没有显式出现的原因。
要坚持使用AstBuilder，您可以用途：

void augmentMethod( MethodNode mn ) {
    def annos = mn.getAnnotations new ClassNode( Grant )
    def rolesValue = annos.first().getMember('value').expressions[0]
    def param = varX( mn.parameters[ 0 ] )
    def guard = new AstBuilder().buildFromSpec {
        ifStatement{
            booleanExpression{
                staticMethodCall( GrantUtil, 'checkAuthorization' ) {
                    argumentList {
                        variable param.name
                        property {
                            classExpression rolesValue.objectExpression.type.typeClass
                            constant rolesValue.propertyAsString
                        }
                    }
                }
            }
            empty()
            returnStatement{ constant null }
        }
    }.first()
    mn.code.statements.add 0, guard
}

可能有一个简化的可能，但上述工作。

错误的原因是传递给argumentList的闭包基本上是一个no-op。你可以在那里写任何你想要的（非DSL）代码，但它不会对生成的代码产生任何直接影响;因此，在运行时最后一次调用时会出现缺少参数的错误。
你必须使用DSL的动词来实际创建参数。在你的例子中，它们是variable和constant。
这是生成正确的代码：

staticMethodCall(GrantUtil, 'checkAuthorization') {
    argumentList {
        variable methodNode.parameters[0].name
        constant AbstractASTTransformation.getMemberStringValue(annos.first(), 'value')
    }
}

编辑

对于记录版本，使其与枚举数组一起工作：

static void augmentMethod(MethodNode methodNode) {
    List<AnnotationNode> annos = methodNode.getAnnotations new ClassNode(Grant)

    IfStatement ifStmt = (IfStatement) new AstBuilder().buildFromSpec {
        ifStatement {
            booleanExpression {
                staticMethodCall(GrantUtil, 'checkAuthorization') {
                    argumentList {
                        variable methodNode.parameters[0].name
                        expression << makeList(annos.first(), 'value')
                    }
                }
            }
            // then
            empty()
            // else
            returnStatement { constant null }
        }
    }.first()

    ((BlockStatement) methodNode.code).statements.add 0, ifStmt
}

static ListExpression makeList(AnnotationNode annotation, String name) {
    Expression expr = annotation.getMember(name)
    if (expr == null) {
        return null
    }
    if (expr instanceof ListExpression) {
        return expr
    }
    return new ListExpression([expr])
}

这只是确保，总是有一个列表字面周围，然后只是采取任何在那里;那我们就把它当成是表达了
这适用于：

@Grant([Permission.user, Permission.anon])
@Grant(Permission.admin)