Invokes the appropriate visit method specific to the type of the node.
@param node the node on which to dispatch
@param p a parameter to be passed to the appropriate visit method
@return the value returns from the appropriate visit method
501361
public final R visit(DocTree node, P p) {
        return (node == null) ? null : node.accept(this, p);
    }
368405
@Override
    public R visitSerialData(SerialDataTree node, P p) {
        return defaultAction(node, p);
    }
3590
@Override
    public R visitAttribute(AttributeTree node, P p) {
        return defaultAction(node, p);
    }
980802
@Override
    public R visitSince(SinceTree node, P p) {
        return scan(node.getBody(), p);
    }
821956
@Override
    public R visitSerial(SerialTree node, P p) {
        return defaultAction(node, p);
    }
122957
@Override
    public R visitErroneous(ErroneousTree node, P p) {
        return defaultAction(node, p);
    }
586860
public boolean visit(MethodInvocation node)
    {
        if (!StringUtils.contains(node.toString(), "."))
        {
            // it must be a local method. ignore.
            return true;
        }
        List<String> qualifiedInstances = new ArrayList<>();
        List<String> argumentsQualified = new ArrayList<>();
        // get qualified arguments of the method
        IMethodBinding resolveTypeBinding = node.resolveMethodBinding();
        final ResolutionStatus resolutionStatus;
        int columnNumber = compilationUnit.getColumnNumber(node.getName().getStartPosition());
        int length = node.getName().getLength();
        if (resolveTypeBinding != null)
        {
            resolutionStatus = ResolutionStatus.RESOLVED;
            ITypeBinding[] argumentTypeBindings = resolveTypeBinding.getParameterTypes();
            List<Expression> arguments = node.arguments();
            int index = 0;
            for (ITypeBinding type : argumentTypeBindings)
            {
                argumentsQualified.add(type.getQualifiedName());

                if (type.isEnum())
                {
                    // there is different number of passed arguments and possible arguments from declaration
                    if (arguments.size() > index)
                    {
                        Expression expression = arguments.get(index);
                        processTypeAsEnum(type, expression, resolutionStatus,
                                compilationUnit.getLineNumber(node.getName().getStartPosition()),
                                columnNumber,
                                length, extractDefinitionLine(node.toString()));
                    }
                    index++;
                }
            }

            // find the interface declaring the method
            if (resolveTypeBinding != null && resolveTypeBinding.getDeclaringClass() != null)
            {
                ITypeBinding declaringClass = resolveTypeBinding.getDeclaringClass();
                qualifiedInstances.add(declaringClass.getQualifiedName());
                ITypeBinding[] interfaces = declaringClass.getInterfaces();
                // Now find all the implemented interfaces having the method called.
                for (ITypeBinding possibleInterface : interfaces)
                {
                    IMethodBinding[] declaredMethods = possibleInterface.getDeclaredMethods();
                    if (declaredMethods.length != 0)
                    {
                        for (IMethodBinding interfaceMethod : declaredMethods)
                        {
                            if (interfaceMethod.getName().equals(node.getName().toString()))
                            {
                                List<String> interfaceMethodArguments = new ArrayList<>();
                                for (ITypeBinding type : interfaceMethod.getParameterTypes())
                                {
                                    interfaceMethodArguments.add(type.getQualifiedName());
                                }
                                if (interfaceMethodArguments.equals(argumentsQualified))
                                {
                                    qualifiedInstances.add(possibleInterface.getQualifiedName());
                                }
                            }
                        }
                    }
                }
            }

        }
        else
        {
            resolutionStatus = ResolutionStatus.RECOVERED;
            String nodeName = StringUtils.removeStart(node.toString(), "this.");
            String objRef = StringUtils.substringBefore(nodeName, "." + node.getName().toString());
            if (state.getNameInstance().containsKey(objRef))
            {
                objRef = state.getNameInstance().get(objRef);
            }
            objRef = resolveClassname(objRef).result;

            @SuppressWarnings("unchecked")
            List<Expression> arguments = node.arguments();
            for (Expression expression : arguments)
            {
                ITypeBinding argumentBinding = expression.resolveTypeBinding();
                if (argumentBinding != null)
                {
                    argumentsQualified.add(argumentBinding.getQualifiedName());

                    if (argumentBinding.isEnum())
                    {
                        // FIXME -- Test
                        String constantEnum = expression.toString();
                        if (constantEnum != null)
                        {
                            processTypeAsEnum(argumentBinding, expression, ResolutionStatus.RESOLVED, compilationUnit.getLineNumber(node.getName().getStartPosition()),
                                    columnNumber, length, extractDefinitionLine(node.toString()));
                        }
                    }
                }
                else
                {
                    PackageAndClassName argumentQualifiedGuess = PackageAndClassName.parseFromQualifiedName(expression.toString());
                    argumentsQualified.add(argumentQualifiedGuess.toString());
                }
            }
            qualifiedInstances.add(objRef);
        }

        for (String qualifiedInstance : qualifiedInstances)
        {
            PackageAndClassName packageAndClassName = PackageAndClassName.parseFromQualifiedName(qualifiedInstance);
            MethodType methodCall = new MethodType(qualifiedInstance, packageAndClassName.packageName, packageAndClassName.className,
                        node.getName().toString(), argumentsQualified);
            processMethod(methodCall, resolutionStatus, TypeReferenceLocation.METHOD_CALL,
                        compilationUnit.getLineNumber(node.getName().getStartPosition()),
                        columnNumber, length, node.toString());
        }

        return super.visit(node);
    }
237186
@Override
    public R visitAssignment(AssignmentTree node, P p) {
        R r = scan(node.getVariable(), p);
        r = scanAndReduce(node.getExpression(), p, r);
        return r;
    }
801606
@Override
    public R visitAuthor(AuthorTree node, P p) {
        return scan(node.getName(), p);
    }
319099
public Object visit(Lookup node) {
        
        Token dotToken = node.getDot();
        SourceInfo info = dotToken.getSourceInfo();
        
        if (info != null && info.getStartPosition() == mDotPosition) {
			
            // Found the matching position, so this node represents the
            // lookup expression that we are looking for.
            
            Expression expression = node.getExpression();
            
            Type type = expression.getType();                
            if (type != null) {
                // Save the type class
                mType = type.getObjectClass();                    
            }                
            
            return null;
        }
        
        return super.visit(node);
    }
987434
@Override
    public R visitIdentifier(IdentifierTree node, P p) {
        return defaultAction(node, p);
    }
1188763
@Override
    public R visitReturn(ReturnTree node, P p) {
        return defaultAction(node, p);
    }
47861
private String getNodeId(PatriciaTrie.PatriciaNode<V> node) {
        if (node == null) {
            return "null";
        } else {
            return node.getKey();
        }
    }
520027
def visit(self, node: AST, dfltChaining: bool = True) -> str:
        """"""
        # print(node.__class__.__name__)
        if node is None:
            return ''
        if isinstance(node, ast.Expression):
            return self.visit(node.body)
        # dispatch to specific or generic method
        method = 'visit_' + node.__class__.__name__
        visitor = getattr(self, method, self.generic_visit)
        return visitor(node, dfltChaining)
200264
@Override
    public R visitThrows(ThrowsTree node, P p) {
        return defaultAction(node, p);
    }
1299641
@Override
    public R visitUses(UsesTree node, P p) {
        return defaultAction(node, p);
    }
1033968
@Override
    public R visitDocRoot(DocRootTree node, P p) {
        return defaultAction(node, p);
    }