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

Example 6 with PropertyExpression

use of org.codehaus.groovy.ast.expr.PropertyExpression 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 7 with PropertyExpression

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

the class ArtefactTypeAstTransformation method resolveArtefactType.

protected String resolveArtefactType(SourceUnit sourceUnit, AnnotationNode annotationNode, ClassNode classNode) {
    Expression value = annotationNode.getMember("value");
    if (value != null) {
        if (value instanceof ConstantExpression) {
            ConstantExpression ce = (ConstantExpression) value;
            return ce.getText();
        }
        if (value instanceof PropertyExpression) {
            PropertyExpression pe = (PropertyExpression) value;
            Expression objectExpression = pe.getObjectExpression();
            if (objectExpression instanceof ClassExpression) {
                ClassExpression ce = (ClassExpression) objectExpression;
                try {
                    Field field = ce.getType().getTypeClass().getDeclaredField(pe.getPropertyAsString());
                    return (String) field.get(null);
                } catch (Exception e) {
                }
            }
        }
    }
    throw new RuntimeException("Class [" + classNode.getName() + "] contains an invalid @Artefact annotation. No artefact found for value specified.");
}

Example 8 with PropertyExpression

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

the class ControllerActionTransformer method getCodeToHandleAllowedMethods.

protected BlockStatement getCodeToHandleAllowedMethods(ClassNode controllerClass, String methodName) {
    GrailsASTUtils.addEnhancedAnnotation(controllerClass, DefaultGrailsControllerClass.ALLOWED_HTTP_METHODS_PROPERTY);
    final BlockStatement checkAllowedMethodsBlock = new BlockStatement();
    final PropertyExpression requestPropertyExpression = new PropertyExpression(new VariableExpression("this"), "request");
    final FieldNode allowedMethodsField = controllerClass.getField(DefaultGrailsControllerClass.ALLOWED_HTTP_METHODS_PROPERTY);
    if (allowedMethodsField != null) {
        final Expression initialAllowedMethodsExpression = allowedMethodsField.getInitialExpression();
        if (initialAllowedMethodsExpression instanceof MapExpression) {
            boolean actionIsRestricted = false;
            final MapExpression allowedMethodsMapExpression = (MapExpression) initialAllowedMethodsExpression;
            final List<MapEntryExpression> allowedMethodsMapEntryExpressions = allowedMethodsMapExpression.getMapEntryExpressions();
            for (MapEntryExpression allowedMethodsMapEntryExpression : allowedMethodsMapEntryExpressions) {
                final Expression allowedMethodsMapEntryKeyExpression = allowedMethodsMapEntryExpression.getKeyExpression();
                if (allowedMethodsMapEntryKeyExpression instanceof ConstantExpression) {
                    final ConstantExpression allowedMethodsMapKeyConstantExpression = (ConstantExpression) allowedMethodsMapEntryKeyExpression;
                    final Object allowedMethodsMapKeyValue = allowedMethodsMapKeyConstantExpression.getValue();
                    if (methodName.equals(allowedMethodsMapKeyValue)) {
                        actionIsRestricted = true;
                        break;
                    }
                }
            }
            if (actionIsRestricted) {
                final PropertyExpression responsePropertyExpression = new PropertyExpression(new VariableExpression("this"), "response");
                final ArgumentListExpression isAllowedArgumentList = new ArgumentListExpression();
                isAllowedArgumentList.addExpression(new ConstantExpression(methodName));
                isAllowedArgumentList.addExpression(new PropertyExpression(new VariableExpression("this"), "request"));
                isAllowedArgumentList.addExpression(new PropertyExpression(new VariableExpression("this"), DefaultGrailsControllerClass.ALLOWED_HTTP_METHODS_PROPERTY));
                final Expression isAllowedMethodCall = new StaticMethodCallExpression(ClassHelper.make(AllowedMethodsHelper.class), "isAllowed", isAllowedArgumentList);
                final BooleanExpression isValidRequestMethod = new BooleanExpression(isAllowedMethodCall);
                final MethodCallExpression sendErrorMethodCall = new MethodCallExpression(responsePropertyExpression, "sendError", new ConstantExpression(HttpServletResponse.SC_METHOD_NOT_ALLOWED));
                final ReturnStatement returnStatement = new ReturnStatement(new ConstantExpression(null));
                final BlockStatement blockToSendError = new BlockStatement();
                blockToSendError.addStatement(new ExpressionStatement(sendErrorMethodCall));
                blockToSendError.addStatement(returnStatement);
                final IfStatement ifIsValidRequestMethodStatement = new IfStatement(isValidRequestMethod, new ExpressionStatement(new EmptyExpression()), blockToSendError);
                checkAllowedMethodsBlock.addStatement(ifIsValidRequestMethodStatement);
            }
        }
    }
    final ArgumentListExpression argumentListExpression = new ArgumentListExpression();
    argumentListExpression.addExpression(new ConstantExpression(ALLOWED_METHODS_HANDLED_ATTRIBUTE_NAME));
    argumentListExpression.addExpression(new ConstantExpression(methodName));
    final Expression setAttributeMethodCall = new MethodCallExpression(requestPropertyExpression, "setAttribute", argumentListExpression);
    final BlockStatement codeToExecuteIfAttributeIsNotSet = new BlockStatement();
    codeToExecuteIfAttributeIsNotSet.addStatement(new ExpressionStatement(setAttributeMethodCall));
    codeToExecuteIfAttributeIsNotSet.addStatement(checkAllowedMethodsBlock);
    final BooleanExpression attributeIsSetBooleanExpression = new BooleanExpression(new MethodCallExpression(requestPropertyExpression, "getAttribute", new ArgumentListExpression(new ConstantExpression(ALLOWED_METHODS_HANDLED_ATTRIBUTE_NAME))));
    final Statement ifAttributeIsAlreadySetStatement = new IfStatement(attributeIsSetBooleanExpression, new EmptyStatement(), codeToExecuteIfAttributeIsNotSet);
    final BlockStatement code = new BlockStatement();
    code.addStatement(ifAttributeIsAlreadySetStatement);
    return code;
}

Example 9 with PropertyExpression

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

the class ControllerActionTransformer method wrapMethodBodyWithExceptionHandling.

/**
     * This will wrap the method body in a try catch block which does something
     * like this:
     * <pre>
     * try {
     *     // original method body here
     * } catch (Exception $caughtException) {
     *     Method $method = getExceptionHandlerMethod($caughtException.getClass())
     *     if($method) {
     *         return $method.invoke(this, $caughtException)
     *     } else {
     *         throw $caughtException
     *     }
     * }
     * </pre>
     * @param methodNode the method to add the try catch block to
     */
protected void wrapMethodBodyWithExceptionHandling(final ClassNode controllerClassNode, final MethodNode methodNode) {
    final BlockStatement catchBlockCode = new BlockStatement();
    final String caughtExceptionArgumentName = "$caughtException";
    final Expression caughtExceptionVariableExpression = new VariableExpression(caughtExceptionArgumentName);
    final Expression caughtExceptionTypeExpression = new PropertyExpression(caughtExceptionVariableExpression, "class");
    final Expression thisExpression = new VariableExpression("this");
    final MethodCallExpression getExceptionHandlerMethodCall = new MethodCallExpression(thisExpression, "getExceptionHandlerMethodFor", caughtExceptionTypeExpression);
    applyDefaultMethodTarget(getExceptionHandlerMethodCall, controllerClassNode);
    final ClassNode reflectMethodClassNode = new ClassNode(Method.class);
    final String exceptionHandlerMethodVariableName = "$method";
    final Expression exceptionHandlerMethodExpression = new VariableExpression(exceptionHandlerMethodVariableName, new ClassNode(Method.class));
    final Expression declareExceptionHandlerMethod = new DeclarationExpression(new VariableExpression(exceptionHandlerMethodVariableName, reflectMethodClassNode), Token.newSymbol(Types.EQUALS, 0, 0), getExceptionHandlerMethodCall);
    final ArgumentListExpression invokeArguments = new ArgumentListExpression();
    invokeArguments.addExpression(thisExpression);
    invokeArguments.addExpression(caughtExceptionVariableExpression);
    final MethodCallExpression invokeExceptionHandlerMethodExpression = new MethodCallExpression(new VariableExpression(exceptionHandlerMethodVariableName), "invoke", invokeArguments);
    applyDefaultMethodTarget(invokeExceptionHandlerMethodExpression, reflectMethodClassNode);
    final Statement returnStatement = new ReturnStatement(invokeExceptionHandlerMethodExpression);
    final Statement throwCaughtExceptionStatement = new ThrowStatement(caughtExceptionVariableExpression);
    final Statement ifExceptionHandlerMethodExistsStatement = new IfStatement(new BooleanExpression(exceptionHandlerMethodExpression), returnStatement, throwCaughtExceptionStatement);
    catchBlockCode.addStatement(new ExpressionStatement(declareExceptionHandlerMethod));
    catchBlockCode.addStatement(ifExceptionHandlerMethodExistsStatement);
    final CatchStatement catchStatement = new CatchStatement(new Parameter(new ClassNode(Exception.class), caughtExceptionArgumentName), catchBlockCode);
    final Statement methodBody = methodNode.getCode();
    BlockStatement tryBlock = new BlockStatement();
    BlockStatement codeToHandleAllowedMethods = getCodeToHandleAllowedMethods(controllerClassNode, methodNode.getName());
    tryBlock.addStatement(codeToHandleAllowedMethods);
    tryBlock.addStatement(methodBody);
    final TryCatchStatement tryCatchStatement = new TryCatchStatement(tryBlock, new EmptyStatement());
    tryCatchStatement.addCatch(catchStatement);
    final ArgumentListExpression argumentListExpression = new ArgumentListExpression();
    argumentListExpression.addExpression(new ConstantExpression(ALLOWED_METHODS_HANDLED_ATTRIBUTE_NAME));
    final PropertyExpression requestPropertyExpression = new PropertyExpression(new VariableExpression("this"), "request");
    final Expression removeAttributeMethodCall = new MethodCallExpression(requestPropertyExpression, "removeAttribute", argumentListExpression);
    final Expression getAttributeMethodCall = new MethodCallExpression(requestPropertyExpression, "getAttribute", new ArgumentListExpression(new ConstantExpression(ALLOWED_METHODS_HANDLED_ATTRIBUTE_NAME)));
    final VariableExpression attributeValueExpression = new VariableExpression("$allowed_methods_attribute_value", ClassHelper.make(Object.class));
    final Expression initializeAttributeValue = new DeclarationExpression(attributeValueExpression, Token.newSymbol(Types.EQUALS, 0, 0), getAttributeMethodCall);
    final Expression attributeValueMatchesMethodNameExpression = new BinaryExpression(new ConstantExpression(methodNode.getName()), Token.newSymbol(Types.COMPARE_EQUAL, 0, 0), attributeValueExpression);
    final Statement ifAttributeValueMatchesMethodName = new IfStatement(new BooleanExpression(attributeValueMatchesMethodNameExpression), new ExpressionStatement(removeAttributeMethodCall), new EmptyStatement());
    final BlockStatement blockToRemoveAttribute = new BlockStatement();
    blockToRemoveAttribute.addStatement(new ExpressionStatement(initializeAttributeValue));
    blockToRemoveAttribute.addStatement(ifAttributeValueMatchesMethodName);
    final TryCatchStatement tryCatchToRemoveAttribute = new TryCatchStatement(blockToRemoveAttribute, new EmptyStatement());
    tryCatchToRemoveAttribute.addCatch(new CatchStatement(new Parameter(ClassHelper.make(Exception.class), "$exceptionRemovingAttribute"), new EmptyStatement()));
    tryCatchStatement.setFinallyStatement(tryCatchToRemoveAttribute);
    methodNode.setCode(tryCatchStatement);
}

Example 10 with PropertyExpression

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

the class VariableExpressionTransformer method tryTransformDelegateToProperty.

private Expression tryTransformDelegateToProperty(VariableExpression expr) {
    // we need to transform variable expressions that go to a delegate
    // to a property expression, as ACG would loose the information
    // in processClassVariable before it reaches any makeCall, that could
    // handle it
    Object val = expr.getNodeMetaData(StaticTypesMarker.IMPLICIT_RECEIVER);
    if (val == null)
        return null;
    VariableExpression implicitThis = new VariableExpression("this");
    PropertyExpression pexp = new PropertyExpression(implicitThis, expr.getName());
    pexp.copyNodeMetaData(expr);
    pexp.setImplicitThis(true);
    ClassNode owner = expr.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER);
    if (owner != null) {
        implicitThis.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, owner);
        implicitThis.putNodeMetaData(StaticTypesMarker.IMPLICIT_RECEIVER, val);
    }
    return pexp;
}