Examples with ModuleNode org.codehaus.groovy.ast.ModuleNode used on opensource projects

Example 1 with ModuleNode

use of org.codehaus.groovy.ast.ModuleNode in project groovy by apache.

the class GenericsUtils method resolveClassNode.

private static ClassNode resolveClassNode(final SourceUnit sourceUnit, final CompilationUnit compilationUnit, final MethodNode mn, final ASTNode usage, final ClassNode parsedNode) {
    ClassNode dummyClass = new ClassNode("dummy", 0, ClassHelper.OBJECT_TYPE);
    dummyClass.setModule(new ModuleNode(sourceUnit));
    dummyClass.setGenericsTypes(mn.getDeclaringClass().getGenericsTypes());
    MethodNode dummyMN = new MethodNode("dummy", 0, parsedNode, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, EmptyStatement.INSTANCE);
    dummyMN.setGenericsTypes(mn.getGenericsTypes());
    dummyClass.addMethod(dummyMN);
    ResolveVisitor visitor = new ResolveVisitor(compilationUnit) {

        @Override
        public void addError(final String msg, final ASTNode expr) {
            sourceUnit.addError(new IncorrectTypeHintException(mn, msg, usage.getLineNumber(), usage.getColumnNumber()));
        }
    };
    visitor.startResolving(dummyClass, sourceUnit);
    return dummyMN.getReturnType();
}

Example 2 with ModuleNode

use of org.codehaus.groovy.ast.ModuleNode in project groovy by apache.

the class AsmClassGenerator method addInnerClass.

public boolean addInnerClass(ClassNode innerClass) {
    ModuleNode mn = controller.getClassNode().getModule();
    innerClass.setModule(mn);
    mn.getUnit().addGeneratedInnerClass((InnerClassNode) innerClass);
    return innerClasses.add(innerClass);
}

Example 3 with ModuleNode

use of org.codehaus.groovy.ast.ModuleNode in project groovy by apache.

the class StaticImportVisitor method transformMapEntryExpression.

// if you have a Bar class with a static foo property, and this:
//   import static Bar.foo as baz
// then this constructor (not normal usage of statics):
//   new Bar(baz:1)
// will become:
//   new Bar(foo:1)
private Expression transformMapEntryExpression(MapEntryExpression me, ClassNode constructorCallType) {
    Expression key = me.getKeyExpression();
    Expression value = me.getValueExpression();
    ModuleNode module = currentClass.getModule();
    if (module != null && key instanceof ConstantExpression) {
        Map<String, ImportNode> importNodes = module.getStaticImports();
        if (importNodes.containsKey(key.getText())) {
            ImportNode importNode = importNodes.get(key.getText());
            if (importNode.getType().equals(constructorCallType)) {
                String newKey = importNode.getFieldName();
                return new MapEntryExpression(new ConstantExpression(newKey), value.transformExpression(this));
            }
        }
    }
    return me;
}

Example 4 with ModuleNode

use of org.codehaus.groovy.ast.ModuleNode in project groovy by apache.

the class StaticImportVisitor method findStaticMethodImportFromModule.

private Expression findStaticMethodImportFromModule(Expression method, Expression args) {
    ModuleNode module = currentClass.getModule();
    if (module == null || !(method instanceof ConstantExpression))
        return null;
    Map<String, ImportNode> importNodes = module.getStaticImports();
    ConstantExpression ce = (ConstantExpression) method;
    Expression expression;
    Object value = ce.getValue();
    // skip non-Strings, e.g. Integer
    if (!(value instanceof String))
        return null;
    final String name = (String) value;
    // when resolving methodCall() or getProp() or setProp()
    if (importNodes.containsKey(name)) {
        ImportNode importNode = importNodes.get(name);
        expression = findStaticMethod(importNode.getType(), importNode.getFieldName(), args);
        if (expression != null)
            return expression;
        expression = findStaticPropertyAccessorGivenArgs(importNode.getType(), getPropNameForAccessor(importNode.getFieldName()), args);
        if (expression != null) {
            return new StaticMethodCallExpression(importNode.getType(), importNode.getFieldName(), args);
        }
    }
    // when resolving getProp() or setProp()
    if (isValidAccessorName(name)) {
        String propName = getPropNameForAccessor(name);
        if (importNodes.containsKey(propName)) {
            ImportNode importNode = importNodes.get(propName);
            ClassNode importClass = importNode.getType();
            String importMember = importNode.getFieldName();
            expression = findStaticMethod(importClass, prefix(name) + capitalize(importMember), args);
            if (expression != null)
                return expression;
            expression = findStaticPropertyAccessorGivenArgs(importClass, importMember, args);
            if (expression != null) {
                return new StaticMethodCallExpression(importClass, prefix(name) + capitalize(importMember), args);
            }
        }
    }
    Map<String, ImportNode> starImports = module.getStaticStarImports();
    ClassNode starImportType;
    if (currentClass.isEnum() && starImports.containsKey(currentClass.getName())) {
        ImportNode importNode = starImports.get(currentClass.getName());
        starImportType = importNode == null ? null : importNode.getType();
        expression = findStaticMethod(starImportType, name, args);
        if (expression != null)
            return expression;
    } else {
        for (ImportNode importNode : starImports.values()) {
            starImportType = importNode == null ? null : importNode.getType();
            expression = findStaticMethod(starImportType, name, args);
            if (expression != null)
                return expression;
            expression = findStaticPropertyAccessorGivenArgs(starImportType, getPropNameForAccessor(name), args);
            if (expression != null) {
                return new StaticMethodCallExpression(starImportType, name, args);
            }
        }
    }
    return null;
}

Example 5 with ModuleNode

use of org.codehaus.groovy.ast.ModuleNode in project groovy by apache.

the class AbstractInterruptibleASTTransformation method visit.

public void visit(ASTNode[] nodes, SourceUnit source) {
    if (nodes.length != 2 || !(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) {
        internalError("Expecting [AnnotationNode, AnnotatedNode] but got: " + Arrays.asList(nodes));
    }
    this.source = source;
    AnnotationNode node = (AnnotationNode) nodes[0];
    AnnotatedNode annotatedNode = (AnnotatedNode) nodes[1];
    if (!type().equals(node.getClassNode())) {
        internalError("Transformation called from wrong annotation: " + node.getClassNode().getName());
    }
    setupTransform(node);
    // should be limited to the current SourceUnit or propagated to the whole CompilationUnit
    final ModuleNode tree = source.getAST();
    if (applyToAllClasses) {
        // guard every class and method defined in this script
        if (tree != null) {
            final List<ClassNode> classes = tree.getClasses();
            for (ClassNode classNode : classes) {
                visitClass(classNode);
            }
        }
    } else if (annotatedNode instanceof ClassNode) {
        // only guard this particular class
        this.visitClass((ClassNode) annotatedNode);
    } else if (!applyToAllMembers && annotatedNode instanceof MethodNode) {
        this.visitMethod((MethodNode) annotatedNode);
        this.visitClass(annotatedNode.getDeclaringClass());
    } else if (!applyToAllMembers && annotatedNode instanceof FieldNode) {
        this.visitField((FieldNode) annotatedNode);
        this.visitClass(annotatedNode.getDeclaringClass());
    } else if (!applyToAllMembers && annotatedNode instanceof DeclarationExpression) {
        this.visitDeclarationExpression((DeclarationExpression) annotatedNode);
        this.visitClass(annotatedNode.getDeclaringClass());
    } else {
        // only guard the script class
        if (tree != null) {
            final List<ClassNode> classes = tree.getClasses();
            for (ClassNode classNode : classes) {
                if (classNode.isScript()) {
                    visitClass(classNode);
                }
            }
        }
    }
}