Examples with GroovyBugError org.codehaus.groovy.GroovyBugError used on opensource projects

Example 46 with GroovyBugError

use of org.codehaus.groovy.GroovyBugError in project groovy-core by groovy.

the class ReadWriteLockASTTransformation method visit.

public void visit(ASTNode[] nodes, SourceUnit source) {
    init(nodes, source);
    AnnotatedNode parent = (AnnotatedNode) nodes[1];
    AnnotationNode node = (AnnotationNode) nodes[0];
    final boolean isWriteLock;
    if (READ_LOCK_TYPE.equals(node.getClassNode())) {
        isWriteLock = false;
    } else if (WRITE_LOCK_TYPE.equals(node.getClassNode())) {
        isWriteLock = true;
    } else {
        throw new GroovyBugError("Internal error: expecting [" + READ_LOCK_TYPE.getName() + ", " + WRITE_LOCK_TYPE.getName() + "]" + " but got: " + node.getClassNode().getName());
    }
    String myTypeName = "@" + node.getClassNode().getNameWithoutPackage();
    String value = getMemberStringValue(node, "value");
    if (parent instanceof MethodNode) {
        MethodNode mNode = (MethodNode) parent;
        ClassNode cNode = mNode.getDeclaringClass();
        String lockExpr = determineLock(value, cNode, mNode.isStatic(), myTypeName);
        if (lockExpr == null)
            return;
        // get lock type
        final Expression lockType;
        if (isWriteLock) {
            lockType = callX(varX(lockExpr, LOCK_TYPE), "writeLock");
        } else {
            lockType = callX(varX(lockExpr, LOCK_TYPE), "readLock");
        }
        Expression acquireLock = callX(lockType, "lock");
        Expression releaseLock = callX(lockType, "unlock");
        Statement originalCode = mNode.getCode();
        mNode.setCode(block(stmt(acquireLock), new TryCatchStatement(originalCode, stmt(releaseLock))));
    }
}

Example 47 with GroovyBugError

use of org.codehaus.groovy.GroovyBugError in project groovy-core by groovy.

the class LogASTTransformation method visit.

public void visit(ASTNode[] nodes, final SourceUnit source) {
    init(nodes, source);
    AnnotatedNode targetClass = (AnnotatedNode) nodes[1];
    AnnotationNode logAnnotation = (AnnotationNode) nodes[0];
    final GroovyClassLoader classLoader = compilationUnit != null ? compilationUnit.getTransformLoader() : source.getClassLoader();
    final LoggingStrategy loggingStrategy = createLoggingStrategy(logAnnotation, classLoader);
    if (loggingStrategy == null)
        return;
    final String logFieldName = lookupLogFieldName(logAnnotation);
    final String categoryName = lookupCategoryName(logAnnotation);
    if (!(targetClass instanceof ClassNode))
        throw new GroovyBugError("Class annotation " + logAnnotation.getClassNode().getName() + " annotated no Class, this must not happen.");
    final ClassNode classNode = (ClassNode) targetClass;
    ClassCodeExpressionTransformer transformer = new ClassCodeExpressionTransformer() {

        private FieldNode logNode;

        @Override
        protected SourceUnit getSourceUnit() {
            return source;
        }

        public Expression transform(Expression exp) {
            if (exp == null)
                return null;
            if (exp instanceof MethodCallExpression) {
                return transformMethodCallExpression(exp);
            }
            return super.transform(exp);
        }

        @Override
        public void visitClass(ClassNode node) {
            FieldNode logField = node.getField(logFieldName);
            if (logField != null && logField.getOwner().equals(node)) {
                addError("Class annotated with Log annotation cannot have log field declared", logField);
            } else if (logField != null && !Modifier.isPrivate(logField.getModifiers())) {
                addError("Class annotated with Log annotation cannot have log field declared because the field exists in the parent class: " + logField.getOwner().getName(), logField);
            } else {
                logNode = loggingStrategy.addLoggerFieldToClass(node, logFieldName, categoryName);
            }
            super.visitClass(node);
        }

        private Expression transformMethodCallExpression(Expression exp) {
            MethodCallExpression mce = (MethodCallExpression) exp;
            if (!(mce.getObjectExpression() instanceof VariableExpression)) {
                return exp;
            }
            VariableExpression variableExpression = (VariableExpression) mce.getObjectExpression();
            if (!variableExpression.getName().equals(logFieldName) || !(variableExpression.getAccessedVariable() instanceof DynamicVariable)) {
                return exp;
            }
            String methodName = mce.getMethodAsString();
            if (methodName == null)
                return exp;
            if (usesSimpleMethodArgumentsOnly(mce))
                return exp;
            variableExpression.setAccessedVariable(logNode);
            if (!loggingStrategy.isLoggingMethod(methodName))
                return exp;
            return loggingStrategy.wrapLoggingMethodCall(variableExpression, methodName, exp);
        }

        private boolean usesSimpleMethodArgumentsOnly(MethodCallExpression mce) {
            Expression arguments = mce.getArguments();
            if (arguments instanceof TupleExpression) {
                TupleExpression tuple = (TupleExpression) arguments;
                for (Expression exp : tuple.getExpressions()) {
                    if (!isSimpleExpression(exp))
                        return false;
                }
                return true;
            }
            return !isSimpleExpression(arguments);
        }

        private boolean isSimpleExpression(Expression exp) {
            if (exp instanceof ConstantExpression)
                return true;
            if (exp instanceof VariableExpression)
                return true;
            return false;
        }
    };
    transformer.visitClass(classNode);
    // GROOVY-6373: references to 'log' field are normally already FieldNodes by now, so revisit scoping
    new VariableScopeVisitor(sourceUnit, true).visitClass(classNode);
}

Example 48 with GroovyBugError

use of org.codehaus.groovy.GroovyBugError in project groovy-core by groovy.

the class AnnotationCollectorTransform method getTargetListFromClass.

private static List<AnnotationNode> getTargetListFromClass(ClassNode alias) {
    Class<?> c = alias.getTypeClass();
    Object[][] data;
    try {
        Method m = c.getMethod("value");
        data = (Object[][]) m.invoke(null);
    } catch (Exception e) {
        throw new GroovyBugError(e);
    }
    return makeListOfAnnotations(data);
}

Example 49 with GroovyBugError

use of org.codehaus.groovy.GroovyBugError in project groovy-core by groovy.

the class Java5 method makeInterfaceTypes.

private void makeInterfaceTypes(CompileUnit cu, ClassNode classNode, Class clazz) {
    Type[] interfaceTypes = clazz.getGenericInterfaces();
    if (interfaceTypes.length == 0) {
        classNode.setInterfaces(ClassNode.EMPTY_ARRAY);
    } else {
        ClassNode[] ret = new ClassNode[interfaceTypes.length];
        for (int i = 0; i < interfaceTypes.length; i++) {
            Type type = interfaceTypes[i];
            while (!(type instanceof Class)) {
                ParameterizedType pt = (ParameterizedType) type;
                Type t2 = pt.getRawType();
                if (t2 == type) {
                    throw new GroovyBugError("Cannot transform generic signature of " + clazz + " with generic interface " + interfaceTypes[i] + " to a class.");
                }
                type = t2;
            }
            ret[i] = makeClassNode(cu, interfaceTypes[i], (Class) type);
        }
        classNode.setInterfaces(ret);
    }
}

Example 50 with GroovyBugError

use of org.codehaus.groovy.GroovyBugError in project grails-core by grails.

the class DelegateAsyncTransformation method visit.

public void visit(ASTNode[] nodes, SourceUnit source) {
    if (nodes.length != 2 || !(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) {
        throw new GroovyBugError("Internal error: expecting [AnnotationNode, AnnotatedNode] but got: " + Arrays.asList(nodes));
    }
    AnnotatedNode parent = (AnnotatedNode) nodes[1];
    AnnotationNode annotationNode = (AnnotationNode) nodes[0];
    if (parent instanceof ClassNode) {
        Expression value = annotationNode.getMember("value");
        if (value instanceof ClassExpression) {
            ClassNode targetApi = value.getType().getPlainNodeReference();
            ClassNode classNode = (ClassNode) parent;
            final String fieldName = '$' + Introspector.decapitalize(targetApi.getNameWithoutPackage());
            FieldNode fieldNode = classNode.getField(fieldName);
            if (fieldNode == null) {
                fieldNode = new FieldNode(fieldName, Modifier.PRIVATE, targetApi, classNode, new ConstructorCallExpression(targetApi, NO_ARGS));
                classNode.addField(fieldNode);
            }
            applyDelegateAsyncTransform(classNode, targetApi, fieldName);
        }
    } else if (parent instanceof FieldNode) {
        FieldNode fieldNode = (FieldNode) parent;
        ClassNode targetApi = fieldNode.getType().getPlainNodeReference();
        ClassNode classNode = fieldNode.getOwner();
        applyDelegateAsyncTransform(classNode, targetApi, fieldNode.getName());
    }
}