Example usage for org.eclipse.jdt.core.dom MethodRefParameter getStartPosition

Introduction

In this page you can find the example usage for org.eclipse.jdt.core.dom MethodRefParameter getStartPosition.

Prototype

public final int getStartPosition() 

Source Link

Document

Returns the character index into the original source file indicating where the source fragment corresponding to this node begins.

Usage

From source file:org.eclipse.jdt.core.dom.ASTConverter.java

License:Open Source License

protected void recordNodes(org.eclipse.jdt.internal.compiler.ast.Javadoc javadoc, TagElement tagElement) {
    Iterator fragments = tagElement.fragments().listIterator();
    while (fragments.hasNext()) {
        ASTNode node = (ASTNode) fragments.next();
        if (node.getNodeType() == ASTNode.MEMBER_REF) {
            MemberRef memberRef = (MemberRef) node;
            Name name = memberRef.getName();
            // get compiler node and record nodes
            int start = name.getStartPosition();
            org.eclipse.jdt.internal.compiler.ast.ASTNode compilerNode = javadoc.getNodeStartingAt(start);
            if (compilerNode != null) {
                recordNodes(name, compilerNode);
                recordNodes(node, compilerNode);
            }//from w  w w  .j ava2s.c om
            // Replace qualifier to have all nodes recorded
            if (memberRef.getQualifier() != null) {
                org.eclipse.jdt.internal.compiler.ast.TypeReference typeRef = null;
                if (compilerNode instanceof JavadocFieldReference) {
                    org.eclipse.jdt.internal.compiler.ast.Expression expression = ((JavadocFieldReference) compilerNode).receiver;
                    if (expression instanceof org.eclipse.jdt.internal.compiler.ast.TypeReference) {
                        typeRef = (org.eclipse.jdt.internal.compiler.ast.TypeReference) expression;
                    }
                } else if (compilerNode instanceof JavadocMessageSend) {
                    org.eclipse.jdt.internal.compiler.ast.Expression expression = ((JavadocMessageSend) compilerNode).receiver;
                    if (expression instanceof org.eclipse.jdt.internal.compiler.ast.TypeReference) {
                        typeRef = (org.eclipse.jdt.internal.compiler.ast.TypeReference) expression;
                    }
                }
                if (typeRef != null) {
                    recordName(memberRef.getQualifier(), typeRef);
                }
            }
        } else if (node.getNodeType() == ASTNode.METHOD_REF) {
            MethodRef methodRef = (MethodRef) node;
            Name name = methodRef.getName();
            // get method name start position
            int start = methodRef.getStartPosition();
            this.scanner.resetTo(start, start + name.getStartPosition() + name.getLength());
            int token;
            try {
                nextToken: while ((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF
                        && token != TerminalTokens.TokenNameLPAREN) {
                    if (token == TerminalTokens.TokenNameERROR && this.scanner.currentCharacter == '#') {
                        start = this.scanner.getCurrentTokenEndPosition() + 1;
                        break nextToken;
                    }
                }
            } catch (InvalidInputException e) {
                // ignore
            }
            // get compiler node and record nodes
            org.eclipse.jdt.internal.compiler.ast.ASTNode compilerNode = javadoc.getNodeStartingAt(start);
            // record nodes
            if (compilerNode != null) {
                recordNodes(methodRef, compilerNode);
                // get type ref
                org.eclipse.jdt.internal.compiler.ast.TypeReference typeRef = null;
                if (compilerNode instanceof org.eclipse.jdt.internal.compiler.ast.JavadocAllocationExpression) {
                    typeRef = ((org.eclipse.jdt.internal.compiler.ast.JavadocAllocationExpression) compilerNode).type;
                    if (typeRef != null)
                        recordNodes(name, compilerNode);
                } else if (compilerNode instanceof org.eclipse.jdt.internal.compiler.ast.JavadocMessageSend) {
                    org.eclipse.jdt.internal.compiler.ast.Expression expression = ((org.eclipse.jdt.internal.compiler.ast.JavadocMessageSend) compilerNode).receiver;
                    if (expression instanceof org.eclipse.jdt.internal.compiler.ast.TypeReference) {
                        typeRef = (org.eclipse.jdt.internal.compiler.ast.TypeReference) expression;
                    }
                    recordNodes(name, compilerNode);
                }
                // record name and qualifier
                if (typeRef != null && methodRef.getQualifier() != null) {
                    recordName(methodRef.getQualifier(), typeRef);
                }
            }
            // Resolve parameters
            Iterator parameters = methodRef.parameters().listIterator();
            while (parameters.hasNext()) {
                MethodRefParameter param = (MethodRefParameter) parameters.next();
                org.eclipse.jdt.internal.compiler.ast.Expression expression = (org.eclipse.jdt.internal.compiler.ast.Expression) javadoc
                        .getNodeStartingAt(param.getStartPosition());
                if (expression != null) {
                    recordNodes(param, expression);
                    if (expression instanceof JavadocArgumentExpression) {
                        JavadocArgumentExpression argExpr = (JavadocArgumentExpression) expression;
                        org.eclipse.jdt.internal.compiler.ast.TypeReference typeRef = argExpr.argument.type;
                        if (this.ast.apiLevel >= AST.JLS3) {
                            param.setVarargs(argExpr.argument.isVarArgs());
                        }
                        recordNodes(param.getType(), typeRef);
                        if (param.getType().isSimpleType()) {
                            recordName(((SimpleType) param.getType()).getName(), typeRef);
                        } else if (param.getType().isArrayType()) {
                            Type type = ((ArrayType) param.getType()).getElementType();
                            recordNodes(type, typeRef);
                            if (type.isSimpleType()) {
                                recordName(((SimpleType) type).getName(), typeRef);
                            }
                        }
                    }
                }
            }
        } else if (node.getNodeType() == ASTNode.SIMPLE_NAME || node.getNodeType() == ASTNode.QUALIFIED_NAME) {
            org.eclipse.jdt.internal.compiler.ast.ASTNode compilerNode = javadoc
                    .getNodeStartingAt(node.getStartPosition());
            recordName((Name) node, compilerNode);
        } else if (node.getNodeType() == ASTNode.TAG_ELEMENT) {
            // resolve member and method references binding
            recordNodes(javadoc, (TagElement) node);
        }
    }
}

---