Examples with Expression org.codehaus.groovy.ast.expr.Expression used on opensource projects

Example 31 with Expression

use of org.codehaus.groovy.ast.expr.Expression in project groovy-core by groovy.

the class SuperCallTraitTransformer method transformPropertyExpression.

private Expression transformPropertyExpression(final PropertyExpression expression) {
    Expression objectExpression = expression.getObjectExpression();
    ClassNode type = objectExpression.getType();
    if (objectExpression instanceof ClassExpression) {
        if (Traits.isTrait(type) && "super".equals(expression.getPropertyAsString())) {
            // SomeTrait.super --> annotate to recognize later
            expression.putNodeMetaData(SuperCallTraitTransformer.class, type);
        }
    }
    return super.transform(expression);
}

Example 32 with Expression

use of org.codehaus.groovy.ast.expr.Expression in project groovy-core by groovy.

the class TraitReceiverTransformer method createArgumentList.

private ArgumentListExpression createArgumentList(final Expression origCallArgs) {
    ArgumentListExpression newArgs = new ArgumentListExpression();
    newArgs.addExpression(new VariableExpression(weaved));
    if (origCallArgs instanceof ArgumentListExpression) {
        List<Expression> expressions = ((ArgumentListExpression) origCallArgs).getExpressions();
        for (Expression expression : expressions) {
            newArgs.addExpression(transform(expression));
        }
    } else {
        newArgs.addExpression(origCallArgs);
    }
    return newArgs;
}

Example 33 with Expression

use of org.codehaus.groovy.ast.expr.Expression in project groovy-core by groovy.

the class Java5 method configureAnnotation.

private void configureAnnotation(AnnotationNode node, Annotation annotation) {
    Class type = annotation.annotationType();
    if (type == Retention.class) {
        Retention r = (Retention) annotation;
        RetentionPolicy value = r.value();
        setRetentionPolicy(value, node);
        node.setMember("value", new PropertyExpression(new ClassExpression(ClassHelper.makeWithoutCaching(RetentionPolicy.class, false)), value.toString()));
    } else if (type == Target.class) {
        Target t = (Target) annotation;
        ElementType[] elements = t.value();
        ListExpression elementExprs = new ListExpression();
        for (ElementType element : elements) {
            elementExprs.addExpression(new PropertyExpression(new ClassExpression(ClassHelper.ELEMENT_TYPE_TYPE), element.name()));
        }
        node.setMember("value", elementExprs);
    } else {
        Method[] declaredMethods;
        try {
            declaredMethods = type.getDeclaredMethods();
        } catch (SecurityException se) {
            declaredMethods = new Method[0];
        }
        for (Method declaredMethod : declaredMethods) {
            try {
                Object value = declaredMethod.invoke(annotation);
                Expression valueExpression = annotationValueToExpression(value);
                if (valueExpression == null)
                    continue;
                node.setMember(declaredMethod.getName(), valueExpression);
            } catch (IllegalAccessException e) {
            } catch (InvocationTargetException e) {
            }
        }
    }
}

Example 34 with Expression

use of org.codehaus.groovy.ast.expr.Expression in project grails-core by grails.

the class AbstractGrailsArtefactTransformer method addEnhancedAnnotation.

protected void addEnhancedAnnotation(ClassNode classNode) {
    final AnnotationNode annotationNode = GrailsASTUtils.addEnhancedAnnotation(classNode);
    AnnotationNode annotation = GrailsASTUtils.findAnnotation(classNode, Mixin.class);
    if (annotation != null) {
        Expression value = annotation.getMember("value");
        if (value != null) {
            annotationNode.setMember("mixins", value);
        }
    }
}

Example 35 with Expression

use of org.codehaus.groovy.ast.expr.Expression in project grails-core by grails.

the class AbstractGrailsArtefactTransformer method performInstanceImplementationInjection.

protected void performInstanceImplementationInjection(SourceUnit source, ClassNode classNode, Map<String, ClassNode> genericsPlaceholders, Class instanceImplementation) {
    ClassNode implementationNode;
    final ConstructorCallExpression constructorCallExpression;
    try {
        implementationNode = GrailsASTUtils.replaceGenericsPlaceholders(ClassHelper.make(instanceImplementation), genericsPlaceholders);
        constructorCallExpression = GrailsASTUtils.hasZeroArgsConstructor(implementationNode) ? new ConstructorCallExpression(implementationNode, ZERO_ARGS) : null;
    } catch (Throwable e) {
        // this may well be ok, as we want to be able to compile against, for example, non servlet environments. In this case just bail out.
        return;
    }
    String apiInstanceProperty = INSTANCE_PREFIX + instanceImplementation.getSimpleName();
    Expression apiInstance = new VariableExpression(apiInstanceProperty, implementationNode);
    if (requiresStaticLookupMethod()) {
        final String lookupMethodName = CURRENT_PREFIX + instanceImplementation.getSimpleName();
        MethodNode lookupMethod = createStaticLookupMethod(classNode, implementationNode, apiInstanceProperty, lookupMethodName);
        apiInstance = new MethodCallExpression(new ClassExpression(classNode), lookupMethodName, ZERO_ARGS);
        ((MethodCallExpression) apiInstance).setMethodTarget(lookupMethod);
    } else if (requiresAutowiring()) {
        PropertyNode propertyNode = new PropertyNode(apiInstanceProperty, Modifier.PUBLIC, implementationNode, classNode, constructorCallExpression, null, null);
        propertyNode.addAnnotation(AUTO_WIRED_ANNOTATION);
        if (getMarkerAnnotation() != null) {
            propertyNode.addAnnotation(getMarkerAnnotation());
        }
        classNode.addProperty(propertyNode);
    } else {
        FieldNode fieldNode = classNode.getField(apiInstanceProperty);
        if (fieldNode == null || (Modifier.isPrivate(fieldNode.getModifiers()) && !fieldNode.getDeclaringClass().equals(classNode))) {
            fieldNode = new FieldNode(apiInstanceProperty, PRIVATE_STATIC_MODIFIER, implementationNode, classNode, constructorCallExpression);
            classNode.addField(fieldNode);
        }
    }
    while (!implementationNode.equals(AbstractGrailsArtefactTransformer.OBJECT_CLASS)) {
        List<MethodNode> declaredMethods = implementationNode.getMethods();
        for (MethodNode declaredMethod : declaredMethods) {
            if (GrailsASTUtils.isConstructorMethod(declaredMethod)) {
                GrailsASTUtils.addDelegateConstructor(classNode, declaredMethod, genericsPlaceholders);
            } else if (isCandidateInstanceMethod(classNode, declaredMethod)) {
                addDelegateInstanceMethod(classNode, apiInstance, declaredMethod, getMarkerAnnotation(), genericsPlaceholders);
            }
        }
        implementationNode = implementationNode.getSuperClass();
    }
    performInjectionInternal(apiInstanceProperty, source, classNode);
}