org.codehaus.groovy.ast.ImportNode Java Examples

public void visit(ASTNode[] nodes, SourceUnit source) {
    init(nodes, source);
    AnnotatedNode parent = (AnnotatedNode) nodes[1];
    AnnotationNode node = (AnnotationNode) nodes[0];
    if (MAVEN_TYPE.equals( node.getClassNode()) || GRADLE_TYPE.equals( node.getClassNode() ))
    {
        type = ( MAVEN_TYPE.equals( node.getClassNode()) ) ? Type.MAVEN : Type.GRADLE;

        if ( parent instanceof DeclarationExpression )
        {
            changeBaseScriptTypeFromDeclaration( (DeclarationExpression) parent, node );
        }
        else if ( parent instanceof ImportNode || parent instanceof PackageNode )
        {
            changeBaseScriptTypeFromPackageOrImport( source, parent, node );
        }
        else if ( parent instanceof ClassNode )
        {
            changeBaseScriptTypeFromClass( (ClassNode) parent );
        }
    }
}
 

public static Range findAddImportRange(ASTNode offsetNode, ASTNodeVisitor astVisitor) {
    ModuleNode moduleNode = (ModuleNode) GroovyASTUtils.getEnclosingNodeOfType(offsetNode, ModuleNode.class,
            astVisitor);
    if (moduleNode == null) {
        return new Range(new Position(0, 0), new Position(0, 0));
    }
    ASTNode afterNode = null;
    if (afterNode == null) {
        List<ImportNode> importNodes = moduleNode.getImports();
        if (importNodes.size() > 0) {
            afterNode = importNodes.get(importNodes.size() - 1);
        }
    }
    if (afterNode == null) {
        afterNode = moduleNode.getPackage();
    }
    if (afterNode == null) {
        return new Range(new Position(0, 0), new Position(0, 0));
    }
    Range nodeRange = GroovyLanguageServerUtils.astNodeToRange(afterNode);
    Position position = new Position(nodeRange.getEnd().getLine() + 1, 0);
    return new Range(position, position);
}
 

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;
}
 

/**
 * Creates the trap and captures all the ways in which a class may be referenced via imports.
 *
 * @param imports        all the imports from the source
 * @param importPackages all the imported packages from the source
 * @param source         the reader source that contains source for the SourceUnit
 * @param sourceUnit     the source unit being compiled. Used for error messages.
 */
AstBuilderInvocationTrap(List<ImportNode> imports, List<ImportNode> importPackages, ReaderSource source, SourceUnit sourceUnit) {
    super(source, sourceUnit);

    // factory type may be references as fully qualified, an import, or an alias
    factoryTargets.add("org.codehaus.groovy.ast.builder.AstBuilder");//default package

    if (imports != null) {
        for (ImportNode importStatement : imports) {
            if ("org.codehaus.groovy.ast.builder.AstBuilder".equals(importStatement.getType().getName())) {
                factoryTargets.add(importStatement.getAlias());
            }
        }
    }

    if (importPackages != null) {
        for (ImportNode importPackage : importPackages) {
            if ("org.codehaus.groovy.ast.builder.".equals(importPackage.getPackageName())) {
                factoryTargets.add("AstBuilder");
                break;
            }
        }
    }
}
 

@Override
public void visitImports(ModuleNode node) {
    for (ImportNode importNode : node.getImports()) {
        final ClassNode importType = importNode.getType();
        if (!importNode.isStar()) {
            // ImportNode itself doesn't contain line/column information, so we need set them manually
            importNode.setLineNumber(importType.getLineNumber());
            importNode.setColumnNumber(importType.getColumnNumber());
            importNode.setLastLineNumber(importType.getLastLineNumber());
            importNode.setLastColumnNumber(importType.getLastColumnNumber());

            if (isEquals(importNode)) {
                usages.add(new ASTUtils.FakeASTNode(importNode, importNode.getClassName()));
            }
        }
    }
    super.visitImports(node);
}
 

@Override
public void visitImports(ModuleNode node) {
	if (node != null) {
		for (ImportNode importNode : node.getImports()) {
			pushASTNode(importNode);
			visitAnnotations(importNode);
			importNode.visit(this);
			popASTNode();
		}
		for (ImportNode importStarNode : node.getStarImports()) {
			pushASTNode(importStarNode);
			visitAnnotations(importStarNode);
			importStarNode.visit(this);
			popASTNode();
		}
		for (ImportNode importStaticNode : node.getStaticImports().values()) {
			pushASTNode(importStaticNode);
			visitAnnotations(importStaticNode);
			importStaticNode.visit(this);
			popASTNode();
		}
		for (ImportNode importStaticStarNode : node.getStaticStarImports().values()) {
			pushASTNode(importStaticStarNode);
			visitAnnotations(importStaticStarNode);
			importStaticStarNode.visit(this);
			popASTNode();
		}
	}
}
 

public void visit(ASTNode[] nodes, SourceUnit source) {
    init(nodes, source);
    AnnotatedNode parent = (AnnotatedNode) nodes[1];
    AnnotationNode node = (AnnotationNode) nodes[0];
    if (!MY_TYPE.equals(node.getClassNode())) return;

    if (parent instanceof DeclarationExpression) {
        changeBaseScriptTypeFromDeclaration((DeclarationExpression) parent, node);
    } else if (parent instanceof ImportNode || parent instanceof PackageNode) {
        changeBaseScriptTypeFromPackageOrImport(source, parent, node);
    } else if (parent instanceof ClassNode) {
        changeBaseScriptTypeFromClass((ClassNode) parent, node);
    }
}
 

private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeViaStaticImport(final CompileUnit compileUnit, final ImportNode importNode, final String typeName, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
    String importClassName = importNode.getClassName();
    ClassNode outerClassNode = compileUnit.getClass(importClassName);

    if (null == outerClassNode) return null;

    String outerNestedClassName = importClassName + "$" + typeName.replace('.', '$');
    ConstructedOuterNestedClassNode constructedOuterNestedClassNode = new ConstructedOuterNestedClassNode(outerClassNode, outerNestedClassName);
    constructedOuterNestedClassNode.addSetRedirectListener(setRedirectListener);
    return constructedOuterNestedClassNode;
}
 

private Expression findStaticProperty(Map<String, ImportNode> importNodes, String accessorName) {
    Expression result = null;
    ImportNode importNode = importNodes.get(accessorName);
    ClassNode importClass = importNode.getType();
    String importMember = importNode.getFieldName();
    result = findStaticPropertyAccessorByFullName(importClass, importMember);
    if (result == null) {
        result = findStaticPropertyAccessor(importClass, getPropNameForAccessor(importMember));
    }
    return result;
}
 

/**
 * For the given {@link Line} and {@link ASTNode} returns colored text. In the
 * returned value there is the same text, but for example keywords are colored,
 * usage itself is bold, etc.
 *
 * @param node concrete usage node
 * @param line line where we have found the usage
 * @return colored text
 */
public static String colorASTNode(final ASTNode node, final Line line) {
    final int columnStart = node.getColumnNumber();
    final int columnEnd = node.getLastColumnNumber();

    if (node instanceof ClassNode) {
        return colorLine(line, ((ClassNode) node).getNameWithoutPackage());
    } else if (node instanceof ConstructorNode) {
        return colorLine(line, ((ConstructorNode) node).getDeclaringClass().getNameWithoutPackage());
    } else if (node instanceof ConstructorCallExpression) {
        return colorLine(line, ((ConstructorCallExpression) node).getType().getNameWithoutPackage());
    } else if (node instanceof MethodNode) {
        return colorLine(line, ((MethodNode) node).getName());
    } else if (node instanceof FieldNode) {
        return colorLine(line, ((FieldNode) node).getName());
    } else if (node instanceof FakeASTNode) {
        // I know this isn't the nicest way, but I can't pass ImportNode directly and
        // don't see easier way how to find out if the FakeASTNode is based on ImportNode
        ASTNode originalNode = ((FakeASTNode) node).getOriginalNode();
        if (originalNode instanceof ImportNode) {
            return colorLine(line, ((ImportNode) originalNode).getAlias());
        }
    }

    final String beforePart = line.createPart(0, columnStart - 1).getText();
    final String usagePart = line.createPart(columnStart - 1, columnEnd - columnStart).getText();
    final String afterPart = line.createPart(columnEnd - 1, line.getText().length()).getText();

    return buildHTML(beforePart, usagePart, afterPart);
}
 

private void addAliasOccurrences(ModuleNode moduleNode, String findingName) {
    for (Map.Entry<String, ImportNode> entry : moduleNode.getStaticImports().entrySet()) {
        if (findingName.equals(entry.getKey())) {
            occurrences.add(new FakeASTNode(entry.getValue().getType(), entry.getKey()));
        }
    }
}
 

@Override
public void visitImports(ModuleNode node) {
    if (FindTypeUtils.isCaretOnClassNode(path, doc, cursorOffset)) {
        for (ImportNode importNode : node.getImports()) {
            addOccurrences(importNode.getType(), (ClassNode) FindTypeUtils.findCurrentNode(path, doc, cursorOffset));
        }
    } else {
        // #233954
        if (leaf instanceof ConstantExpression && leafParent instanceof MethodCallExpression) {
            addAliasOccurrences(node, ((MethodCallExpression) leafParent).getMethodAsString());
        }

        // #234000
        if (leaf instanceof VariableExpression) {
            addAliasOccurrences(node, ((VariableExpression) leaf).getName());
        }

        // For both: #233954 and #234000
        if (leaf instanceof BlockStatement) {
            for (Map.Entry<String, ImportNode> entry : node.getStaticImports().entrySet()) {
                OffsetRange range = ASTUtils.getNextIdentifierByName(doc, entry.getKey(), cursorOffset);
                if (range.containsInclusive(cursorOffset)) {
                    occurrences.add(new FakeASTNode(entry.getValue().getType(), entry.getKey()));
                }
            }
        }
    }
    super.visitImports(node);
}
 

@Override
public void visitMethodCallExpression(MethodCallExpression methodCall) {
    if (!FindTypeUtils.isCaretOnClassNode(path, doc, cursorOffset)) {
        if (leaf instanceof MethodNode) {
            MethodNode method = (MethodNode) leaf;
            if (Methods.isSameMethod(method, methodCall)) {
                occurrences.add(methodCall);
            }
        } else if (leaf instanceof ConstantExpression && leafParent instanceof MethodCallExpression) {
            if (Methods.isSameMethod(methodCall, (MethodCallExpression) leafParent)) {
                occurrences.add(methodCall);
            }
        }

        // #234000
        if (leaf instanceof BlockStatement) {
            ASTNode root = path.root();
            if (root instanceof ModuleNode) {
                for (Map.Entry<String, ImportNode> entry : ((ModuleNode) root).getStaticImports().entrySet()) {
                    String alias = entry.getKey();
                    if (!alias.equals(methodCall.getMethodAsString())) {
                        continue;
                    }

                    OffsetRange range = ASTUtils.getNextIdentifierByName(doc, alias, cursorOffset);
                    if (range.containsInclusive(cursorOffset)) {
                        occurrences.add(methodCall);
                    }
                }
            }
        }
    }
    super.visitMethodCallExpression(methodCall);
}
 

@Override
public void visitImports(ModuleNode node) {
    for (ImportNode importNode : node.getImports()) {
        imports.add(importNode.getType().getNameWithoutPackage());
    }
    super.visitImports(node);
}
 

private static ClassNode getCurrentImportNode(ModuleNode moduleNode, BaseDocument doc, int caret) {
    for (ImportNode importNode : moduleNode.getImports()) {
        if (isCaretOnImportStatement(importNode, doc, caret)) {
            if (!importNode.isStar()) {
                return ElementUtils.getType(importNode);
            }
        }
    }
    return null;
}
 

@Override
public void computeHints(GroovyHintsProvider.GroovyRuleContext context, List<Hint> result) {
    final ModuleNode moduleNode = context.getGroovyParserResult().getRootElement().getModuleNode();
    if (null == moduleNode) {
        return;
    }
    List<ImportNode> importNodes = moduleNode.getImports();
    for (ImportNode importNode : importNodes) {
        
        String alias = importNode.getAlias();
        
        try {
            int find = 0;
            final FinderFactory.StringFwdFinder stringFwdFinder = new FinderFactory.StringFwdFinder(alias, true);
            
            while(-1 != (find = context.doc.find(stringFwdFinder, find+1, -1)) && skipUsage(find, context.doc));
            
            if (-1 == find) {
                result.add(new Hint(this, "Unused Import", 
                        NbEditorUtilities.getFileObject(context.doc), 
                        ASTUtils.getRangeFull(importNode, context.doc), 
                        Collections.<HintFix>singletonList(new RemoveUnusedImportFix("Remove unused import", context.doc, importNode)), 1));
            }             
        } catch (BadLocationException ex) {
            Exceptions.printStackTrace(ex);
        }
    }
}
 

@Override
public void visitVariableExpression(VariableExpression variableExpression) {
    final ClassNode visitedType = variableExpression.getType();
    final String visitedName = variableExpression.getName();

    if (FindTypeUtils.isCaretOnClassNode(path, doc, cursorOffset)) {
        addOccurrences(visitedType, (ClassNode) FindTypeUtils.findCurrentNode(path, doc, cursorOffset));
    } else {
        if (leaf instanceof FieldNode) {
            if (visitedName.equals(((FieldNode) leaf).getName())) {
                occurrences.add(variableExpression);
            }
        } else if (leaf instanceof PropertyNode) {
            if (visitedName.equals(((PropertyNode) leaf).getField().getName())) {
                occurrences.add(variableExpression);
            }
        } else if (leaf instanceof Variable) {
            if (visitedName.equals(((Variable) leaf).getName())) {
                occurrences.add(variableExpression);
            }
        } else if (leaf instanceof ForStatement) {
            if (visitedName.equals(((ForStatement) leaf).getVariable().getName())) {
                occurrences.add(variableExpression);
            }
        } else if (leaf instanceof ConstantExpression && leafParent instanceof PropertyExpression) {
            PropertyExpression property = (PropertyExpression) leafParent;
            if (variableExpression.getName().equals(property.getPropertyAsString())) {
                occurrences.add(variableExpression);
            }

        // #234000
        } else if (leaf instanceof BlockStatement) {
            ASTNode root = path.root();
            if (root instanceof ModuleNode) {
                for (Map.Entry<String, ImportNode> entry : ((ModuleNode) root).getStaticImports().entrySet()) {
                    String alias = entry.getKey();

                    if (!alias.equals(variableExpression.getName())) {
                        continue;
                    }

                    OffsetRange range = ASTUtils.getNextIdentifierByName(doc, alias, cursorOffset);
                    if (range.containsInclusive(cursorOffset)) {
                        occurrences.add(variableExpression);
                    }
                }
            }
        }
    }
    super.visitVariableExpression(variableExpression);
}
 

public static ClassNode getDeclaringClass(ASTNode node) {
    if (node instanceof ClassNode) {
        return (ClassNode) node;
    } else if (node instanceof AnnotationNode) {
        return ((AnnotationNode) node).getClassNode();
    } else if (node instanceof MethodNode) {
        return ((MethodNode) node).getDeclaringClass();
    } else if (node instanceof FieldNode) {
        return ((FieldNode) node).getDeclaringClass();
    } else if (node instanceof PropertyNode) {
        return ((PropertyNode) node).getDeclaringClass();
    } else if (node instanceof Parameter) {
        return ((Parameter) node).getDeclaringClass();
    } else if (node instanceof ForStatement) {
        return ((ForStatement) node).getVariableType().getDeclaringClass();
    } else if (node instanceof CatchStatement) {
        return ((CatchStatement) node).getVariable().getDeclaringClass();
    } else if (node instanceof ImportNode) {
        return ((ImportNode) node).getDeclaringClass();
    } else if (node instanceof ClassExpression) {
        return ((ClassExpression) node).getType().getDeclaringClass();
    } else if (node instanceof VariableExpression) {
        return ((VariableExpression) node).getDeclaringClass();
    } else if (node instanceof DeclarationExpression) {
        DeclarationExpression declaration = ((DeclarationExpression) node);
        if (declaration.isMultipleAssignmentDeclaration()) {
            return declaration.getTupleExpression().getDeclaringClass();
        } else {
            return declaration.getVariableExpression().getDeclaringClass();
        }
    } else if (node instanceof ConstantExpression) {
        return ((ConstantExpression) node).getDeclaringClass();
    } else if (node instanceof MethodCallExpression) {
        return ((MethodCallExpression) node).getType();
    } else if (node instanceof ConstructorCallExpression) {
        return ((ConstructorCallExpression) node).getType();
    } else if (node instanceof ArrayExpression) {
        return ((ArrayExpression) node).getDeclaringClass();
    }

    throw new IllegalStateException("Not implemented yet - GroovyRefactoringElement.getDeclaringClass() ..looks like the type: " + node.getClass().getName() + " isn't handled at the moment!"); // NOI18N
}
 

public static String getNameWithoutPackage(ASTNode node) {
    if (node instanceof FakeASTNode) {
        node = ((FakeASTNode) node).getOriginalNode();
    }

    String name = null;
    if (node instanceof ClassNode) {
        name = ((ClassNode) node).getNameWithoutPackage();
    } else if (node instanceof AnnotationNode) {
        return ((AnnotationNode) node).getText();
    } else if (node instanceof MethodNode) {
        name = ((MethodNode) node).getName();
        if ("<init>".equals(name)) { // NOI18N
            name = getDeclaringClassNameWithoutPackage(node);
        }
    } else if (node instanceof FieldNode) {
        name = ((FieldNode) node).getName();
    } else if (node instanceof PropertyNode) {
        name = ((PropertyNode) node).getName();
    } else if (node instanceof Parameter) {
        name = ((Parameter) node).getName();
    } else if (node instanceof ForStatement) {
        name = ((ForStatement) node).getVariableType().getNameWithoutPackage();
    } else if (node instanceof CatchStatement) {
        name = ((CatchStatement) node).getVariable().getName();
    } else if (node instanceof ImportNode) {
        name = ((ImportNode) node).getType().getNameWithoutPackage();
    } else if (node instanceof ClassExpression) {
        name = ((ClassExpression) node).getType().getNameWithoutPackage();
    } else if (node instanceof VariableExpression) {
        name = ((VariableExpression) node).getName();
    } else if (node instanceof DeclarationExpression) {
        DeclarationExpression declaration = ((DeclarationExpression) node);
        if (declaration.isMultipleAssignmentDeclaration()) {
            name = declaration.getTupleExpression().getType().getNameWithoutPackage();
        } else {
            name = declaration.getVariableExpression().getType().getNameWithoutPackage();
        }
    } else if (node instanceof ConstantExpression) {
        name = ((ConstantExpression) node).getText();
    } else if (node instanceof MethodCallExpression) {
        name = ((MethodCallExpression) node).getMethodAsString();
    } else if (node instanceof ConstructorCallExpression) {
        name = ((ConstructorCallExpression) node).getType().getNameWithoutPackage();
    } else if (node instanceof ArrayExpression) {
        name = ((ArrayExpression) node).getElementType().getNameWithoutPackage();
    }


    if (name != null) {
        return normalizeTypeName(name, null);
    }
    throw new IllegalStateException("Not implemented yet - GroovyRefactoringElement.getName() needs to be improve for type: " + node.getClass().getSimpleName()); // NOI18N
}
 

/**
 * Returns type for the given ASTNode. For example if FieldNode is passed
 * as a parameter, it returns type of the given field etc. If the Method call
 * is passed as a parameter, the method tried to interfere proper type and return it
 *
 * @param node where we want to know declared type
 * @return type of the given node
 * @throws IllegalStateException if an implementation is missing for the given ASTNode type
 */
public static ClassNode getType(ASTNode node) {
    if (node instanceof FakeASTNode) {
        node = ((FakeASTNode) node).getOriginalNode();
    }

    if (node instanceof ClassNode) {
        ClassNode clazz = ((ClassNode) node);
        if (clazz.getComponentType() != null) {
            return clazz.getComponentType();
        } else {
            return clazz;
        }
    } else if (node instanceof AnnotationNode) {
        return ((AnnotationNode) node).getClassNode();
    } else if (node instanceof FieldNode) {
        return ((FieldNode) node).getType();
    } else if (node instanceof PropertyNode) {
        return ((PropertyNode) node).getType();
    } else if (node instanceof MethodNode) {
        return ((MethodNode) node).getReturnType();
    } else if (node instanceof Parameter) {
       return ((Parameter) node).getType();
    } else if (node instanceof ForStatement) {
        return ((ForStatement) node).getVariableType();
    } else if (node instanceof CatchStatement) {
        return ((CatchStatement) node).getVariable().getOriginType();
    } else if (node instanceof ImportNode) {
        return ((ImportNode) node).getType();
    } else if (node instanceof ClassExpression) {
        return ((ClassExpression) node).getType();
    } else if (node instanceof VariableExpression) {
        return ((VariableExpression) node).getType();
    } else if (node instanceof DeclarationExpression) {
        DeclarationExpression declaration = ((DeclarationExpression) node);
        if (declaration.isMultipleAssignmentDeclaration()) {
            return declaration.getTupleExpression().getType();
        } else {
            return declaration.getVariableExpression().getType();
        }
    } else if (node instanceof ConstructorCallExpression) {
        return ((ConstructorCallExpression) node).getType();
    } else if (node instanceof ArrayExpression) {
        return ((ArrayExpression) node).getElementType();
    }
    throw new IllegalStateException("Not implemented yet - GroovyRefactoringElement.getType() needs to be improve!"); // NOI18N
}
 

private static OffsetRange getImportRange(ImportNode importNode, BaseDocument doc, int cursorOffset) {
    return getRange(importNode.getType(), doc, cursorOffset);
}
 

private static boolean isCaretOnImportStatement(ImportNode importNode, BaseDocument doc, int cursorOffset) {
    if (getImportRange(importNode, doc, cursorOffset) != OffsetRange.NONE) {
        return true;
    }
    return false;
}
 

public RemoveUnusedImportFix(String desc, BaseDocument baseDoc, ImportNode importNode) {
    this.desc = desc;
    this.baseDoc = baseDoc;
    this.importNode = importNode;
}
 

public static ASTNode getDefinition(ASTNode node, boolean strict, ASTNodeVisitor astVisitor) {
    if (node == null) {
        return null;
    }
    ASTNode parentNode = astVisitor.getParent(node);
    if (node instanceof ExpressionStatement) {
        ExpressionStatement statement = (ExpressionStatement) node;
        node = statement.getExpression();
    }
    if (node instanceof ClassNode) {
        return tryToResolveOriginalClassNode((ClassNode) node, strict, astVisitor);
    } else if (node instanceof ConstructorCallExpression) {
        ConstructorCallExpression callExpression = (ConstructorCallExpression) node;
        return GroovyASTUtils.getMethodFromCallExpression(callExpression, astVisitor);
    } else if (node instanceof DeclarationExpression) {
        DeclarationExpression declExpression = (DeclarationExpression) node;
        if (!declExpression.isMultipleAssignmentDeclaration()) {
            ClassNode originType = declExpression.getVariableExpression().getOriginType();
            return tryToResolveOriginalClassNode(originType, strict, astVisitor);
        }
    } else if (node instanceof ClassExpression) {
        ClassExpression classExpression = (ClassExpression) node;
        return tryToResolveOriginalClassNode(classExpression.getType(), strict, astVisitor);
    } else if (node instanceof ImportNode) {
        ImportNode importNode = (ImportNode) node;
        return tryToResolveOriginalClassNode(importNode.getType(), strict, astVisitor);
    } else if (node instanceof MethodNode) {
        return node;
    } else if (node instanceof ConstantExpression && parentNode != null) {
        if (parentNode instanceof MethodCallExpression) {
            MethodCallExpression methodCallExpression = (MethodCallExpression) parentNode;
            return GroovyASTUtils.getMethodFromCallExpression(methodCallExpression, astVisitor);
        } else if (parentNode instanceof PropertyExpression) {
            PropertyExpression propertyExpression = (PropertyExpression) parentNode;
            PropertyNode propNode = GroovyASTUtils.getPropertyFromExpression(propertyExpression, astVisitor);
            if (propNode != null) {
                return propNode;
            }
            return GroovyASTUtils.getFieldFromExpression(propertyExpression, astVisitor);
        }
    } else if (node instanceof VariableExpression) {
        VariableExpression variableExpression = (VariableExpression) node;
        Variable accessedVariable = variableExpression.getAccessedVariable();
        if (accessedVariable instanceof ASTNode) {
            return (ASTNode) accessedVariable;
        }
        // DynamicVariable is not an ASTNode, so skip it
        return null;
    } else if (node instanceof Variable) {
        return node;
    }
    return null;
}
 

private String getAnnotationValue(Object memberValue) {
    String val = "null";
    if (memberValue instanceof ListExpression) {
        StringBuilder sb = new StringBuilder("{");
        boolean first = true;
        ListExpression le = (ListExpression) memberValue;
        for (Expression e : le.getExpressions()) {
            if (first) first = false;
            else sb.append(",");
            sb.append(getAnnotationValue(e));
        }
        sb.append("}");
        val = sb.toString();
    } else if (memberValue instanceof ConstantExpression) {
        ConstantExpression ce = (ConstantExpression) memberValue;
        Object constValue = ce.getValue();
        if (constValue instanceof AnnotationNode) {
            Writer writer = new StringBuilderWriter();
            PrintWriter out = new PrintWriter(writer);
            printAnnotation(out, (AnnotationNode) constValue);
            val = writer.toString();
        } else if (constValue instanceof Number || constValue instanceof Boolean)
            val = constValue.toString();
        else
            val = "\"" + escapeSpecialChars(constValue.toString()) + "\"";
    } else if (memberValue instanceof PropertyExpression) {
        // assume must be static class field or enum value or class that Java can resolve
        val = ((Expression) memberValue).getText();
    } else if (memberValue instanceof VariableExpression) {
        val = ((Expression) memberValue).getText();
        //check for an alias
        ImportNode alias = currentModule.getStaticImports().get(val);
        if (alias != null)
            val = alias.getClassName() + "." + alias.getFieldName();
    } else if (memberValue instanceof ClosureExpression) {
        // annotation closure; replaced with this specific class literal to cover the
        // case where annotation type uses Class<? extends Closure> for the closure's type
        val = "groovy.lang.Closure.class";
    } else if (memberValue instanceof ClassExpression) {
        val = ((Expression) memberValue).getText() + ".class";
    }
    return val;
}
 

public CompletableFuture<Either<List<CompletionItem>, CompletionList>> provideCompletion(
		TextDocumentIdentifier textDocument, Position position, CompletionContext context) {
	if (ast == null) {
		//this shouldn't happen, but let's avoid an exception if something
		//goes terribly wrong.
		return CompletableFuture.completedFuture(Either.forLeft(Collections.emptyList()));
	}
	URI uri = URI.create(textDocument.getUri());
	ASTNode offsetNode = ast.getNodeAtLineAndColumn(uri, position.getLine(), position.getCharacter());
	if (offsetNode == null) {
		return CompletableFuture.completedFuture(Either.forLeft(Collections.emptyList()));
	}
	ASTNode parentNode = ast.getParent(offsetNode);

	isIncomplete = false;
	List<CompletionItem> items = new ArrayList<>();

	if (offsetNode instanceof PropertyExpression) {
		populateItemsFromPropertyExpression((PropertyExpression) offsetNode, position, items);
	} else if (parentNode instanceof PropertyExpression) {
		populateItemsFromPropertyExpression((PropertyExpression) parentNode, position, items);
	} else if (offsetNode instanceof MethodCallExpression) {
		populateItemsFromMethodCallExpression((MethodCallExpression) offsetNode, position, items);
	} else if (offsetNode instanceof ConstructorCallExpression) {
		populateItemsFromConstructorCallExpression((ConstructorCallExpression) offsetNode, position, items);
	} else if (parentNode instanceof MethodCallExpression) {
		populateItemsFromMethodCallExpression((MethodCallExpression) parentNode, position, items);
	} else if (offsetNode instanceof VariableExpression) {
		populateItemsFromVariableExpression((VariableExpression) offsetNode, position, items);
	} else if (offsetNode instanceof ImportNode) {
		populateItemsFromImportNode((ImportNode) offsetNode, position, items);
	} else if (offsetNode instanceof ClassNode) {
		populateItemsFromClassNode((ClassNode) offsetNode, position, items);
	} else if (offsetNode instanceof MethodNode) {
		populateItemsFromScope(offsetNode, "", items);
	} else if (offsetNode instanceof Statement) {
		populateItemsFromScope(offsetNode, "", items);
	}

	if (isIncomplete) {
		return CompletableFuture.completedFuture(Either.forRight(new CompletionList(true, items)));
	}
	return CompletableFuture.completedFuture(Either.forLeft(items));
}