Uses of Class
com.github.javaparser.ast.Node

Packages that use Node

Package	Description
com.github.javaparser
com.github.javaparser.ast
com.github.javaparser.ast.body
com.github.javaparser.ast.comments
com.github.javaparser.ast.expr
com.github.javaparser.ast.modules
com.github.javaparser.ast.nodeTypes
com.github.javaparser.ast.nodeTypes.modifiers
com.github.javaparser.ast.observer
com.github.javaparser.ast.stmt
com.github.javaparser.ast.type
com.github.javaparser.ast.validator
com.github.javaparser.ast.validator.language_level_validations
com.github.javaparser.ast.validator.language_level_validations.chunks
com.github.javaparser.ast.validator.postprocessors
com.github.javaparser.ast.visitor
com.github.javaparser.metamodel
com.github.javaparser.printer
com.github.javaparser.printer.concretesyntaxmodel
com.github.javaparser.printer.lexicalpreservation
com.github.javaparser.printer.lexicalpreservation.changes
com.github.javaparser.resolution
com.github.javaparser.resolution.declarations
com.github.javaparser.symbolsolver
com.github.javaparser.symbolsolver.javaparsermodel	Implementation of model based on JavaParser.
com.github.javaparser.symbolsolver.javaparsermodel.contexts
com.github.javaparser.symbolsolver.javaparsermodel.declarations
com.github.javaparser.symbolsolver.javaparsermodel.declarators
com.github.javaparser.symbolsolver.javassistmodel	Implementation of model based on Javassist.
com.github.javaparser.symbolsolver.reflectionmodel	Implementation of model based on reflection.
com.github.javaparser.symbolsolver.resolution
com.github.javaparser.symbolsolver.resolution.naming
com.github.javaparser.symbolsolver.resolution.typeinference
com.github.javaparser.utils

Uses of Node in com.github.javaparser

Classes in com.github.javaparser with type parameters of type Node

Modifier and Type	Class	Description
(package private) class	RangedList<T extends Node>	Helper class for GeneratedJavaParser

Methods in com.github.javaparser with type parameters of type Node

Modifier and Type	Method	Description
(package private) <T extends Node> NodeList<T>	GeneratedJavaParserBase.add(NodeList<T> list, T obj)	Add obj to list and return it.
(package private) <T extends Node> NodeList<T>	GeneratedJavaParserBase.addWhenNotNull(NodeList<T> list, T obj)	Add obj to list only when list is not null
(package private) <T extends Node> NodeList<T>	GeneratedJavaParserBase.emptyNodeList()	Quickly create a new, empty, NodeList
private <T extends Node> T	JavaParserAdapter.handleResult(ParseResult<T> result)	Helper function to handle the result in a simpler way.
private static <T extends Node> T	StaticJavaParser.handleResult(ParseResult<T> result)	Deprecated.
<N extends Node> ParseResult<N>	JavaParser.parse(ParseStart<N> start, Provider provider)	Parses source code.
(package private) <T extends Node> NodeList<T>	GeneratedJavaParserBase.prepend(NodeList<T> list, T obj)	Add obj to list at position pos

Methods in com.github.javaparser that return Node

Modifier and Type	Method	Description
Node	HasParentNode.getParentNodeForChildren()	Returns the parent node from the perspective of the children of this node.

Methods in com.github.javaparser that return types with arguments of type Node

Modifier and Type	Method	Description
Optional<Node>	HasParentNode.getParentNode()	Returns the parent node, or Optional.empty if no parent is set.

Methods in com.github.javaparser with parameters of type Node

Modifier and Type	Method	Description
private boolean	CommentsInserter.attributeLineCommentToNodeOrChild(Node node, LineComment lineComment)
private boolean	CommentsInserter.commentIsOnNextLine(Node a, Comment c)
(package private) void	CommentsInserter.insertComments(Node node, TreeSet<Comment> commentsToAttribute)	This method try to attributes the nodes received to child of the node.
default boolean	HasParentNode.isDescendantOf(Node ancestor)	Determines whether this HasParentNode node is a descendant of the given node.
(package private) JavaToken	GeneratedJavaParserBase.orIfInvalid(JavaToken firstChoice, Node secondChoice)
private void	GeneratedJavaParserBase.propagateRangeGrowthOnRight(Node node, Node endNode)	Propagate expansion of the range on the right to the parent.
(package private) TokenRange	GeneratedJavaParserBase.range(Node begin, Node end)	Return a TokenRange spanning from begin to end
(package private) TokenRange	GeneratedJavaParserBase.range(Node begin, JavaToken end)	Return a TokenRange spanning from begin to end
(package private) TokenRange	GeneratedJavaParserBase.range(JavaToken begin, Node end)	Return a TokenRange spanning from begin to end
T	HasParentNode.setParentNode(Node parentNode)	Sets the parent node.
private boolean	CommentsInserter.thereAreLinesBetween(Node a, Node b)

Method parameters in com.github.javaparser with type arguments of type Node

Modifier and Type	Method	Description
private void	CommentsInserter.attributeLineCommentsOnSameLine(TreeSet<Comment> commentsToAttribute, List<Node> children)
void	ParserConfiguration.LineEndingProcessor.postProcess(ParseResult<? extends Node> result, ParserConfiguration configuration)
void	ParserConfiguration.UnicodeEscapeProcessor.postProcess(ParseResult<? extends Node> result, ParserConfiguration configuration)
void	Processor.postProcess(ParseResult<? extends Node> result, ParserConfiguration configuration)	Makes the parser do a post-parsing step before the result is returned to the user.

Uses of Node in com.github.javaparser.ast

Classes in com.github.javaparser.ast with type parameters of type Node

Modifier and Type	Class	Description
class	NodeList<N extends Node>	A list of nodes.

Subclasses of Node in com.github.javaparser.ast

Modifier and Type	Class	Description
class	ArrayCreationLevel	In new int[1][2]; there are two ArrayCreationLevel objects, the first one contains the expression "1", the second the expression "2".
class	CompilationUnit	This class represents the entire compilation unit.
class	ImportDeclaration	An import declaration.
class	Modifier	A modifier, like private, public, or volatile.
class	PackageDeclaration	A package declaration.

Classes in com.github.javaparser.ast that implement interfaces with type arguments of type Node

Modifier and Type	Class	Description
class	Node	Base class for all nodes of the abstract syntax tree.
class	Node	Base class for all nodes of the abstract syntax tree.
class	Node	Base class for all nodes of the abstract syntax tree.
static class	Node.BreadthFirstIterator	Performs a breadth-first node traversal starting with a given node.
static class	Node.DirectChildrenIterator	Performs a simple traversal over all nodes that have the passed node as their parent.
static class	Node.ParentsVisitor	Iterates over the parent of the node, then the parent's parent, then the parent's parent's parent, until running out of parents.
static class	Node.PostOrderIterator	Performs a post-order (or leaves-first) node traversal starting with a given node.
static class	Node.PreOrderIterator	Performs a pre-order (or depth-first) node traversal starting with a given node.

Fields in com.github.javaparser.ast declared as Node

Modifier and Type	Field	Description
(package private) N	NodeList.NodeListIterator.current
private Node	Node.ParentsVisitor.node
private Node	Node.parentNode
private Node	NodeList.parentNode

Fields in com.github.javaparser.ast with type parameters of type Node

Modifier and Type	Field	Description
private ArrayList<Node>	Node.childNodes
private final Iterator<Node>	Node.DirectChildrenIterator.childrenIterator
private final List<Node>	Node.PostOrderIterator.Level.nodes
private final Queue<Node>	Node.BreadthFirstIterator.queue
private final Stack<Node>	Node.PreOrderIterator.stack

Methods in com.github.javaparser.ast with type parameters of type Node

Modifier and Type	Method	Description
<T extends Node> List<T>	Node.findAll(Class<T> nodeType)	Walks the AST with pre-order traversal, returning all nodes of type "nodeType".
<T extends Node> List<T>	Node.findAll(Class<T> nodeType, Node.TreeTraversal traversal)	Walks the AST with specified traversal order, returning all nodes of type "nodeType".
<T extends Node> List<T>	Node.findAll(Class<T> nodeType, Predicate<T> predicate)	Walks the AST with pre-order traversal, returning all nodes of type "nodeType" that match the predicate.
<N extends Node> Optional<N>	Node.findFirst(Class<N> nodeType)	Walks the AST with pre-order traversal, returning the first node of type "nodeType" or empty() if none is found.
<N extends Node> Optional<N>	Node.findFirst(Class<N> nodeType, Predicate<N> predicate)	Walks the AST with pre-order traversal, returning the first node of type "nodeType" that matches "predicate" or empty() if none is found.
<N extends Node> List<N>	Node.getChildNodesByType(Class<N> clazz)	Deprecated. use Node.findAll(Class) but be aware that findAll also considers the initial node.
<N extends Node> List<N>	Node.getNodesByType(Class<N> clazz)	Deprecated. use Node.findAll(Class) but be aware that findAll also considers the initial node.
static <X extends Node> NodeList<X>	NodeList.nodeList(NodeList<X> nodes)
static <X extends Node> NodeList<X>	NodeList.nodeList(Collection<X> nodes)
static <X extends Node> NodeList<X>	NodeList.nodeList(X... nodes)
static <T extends Node> Collector<T, NodeList<T>, NodeList<T>>	NodeList.toNodeList()
<T extends Node> void	Node.walk(Class<T> nodeType, Consumer<T> consumer)	Walks the AST with pre-order traversal, calling the consumer for every node of type "nodeType".

Methods in com.github.javaparser.ast that return Node

Modifier and Type	Method	Description
Node	Node.clone()
Node	Node.findRootNode()	Finds the root node of this AST by finding the topmost parent.
Node	Node.PostOrderIterator.Level.getCurrent()	Returns the current node.
private Node	Node.PostOrderIterator.getNextAndCleanupStack(Node.PostOrderIterator.Level state)
Node	Node.getParentNodeForChildren()
Node	NodeList.getParentNodeForChildren()
Node	Node.BreadthFirstIterator.next()
Node	Node.DirectChildrenIterator.next()
Node	Node.ParentsVisitor.next()
Node	Node.PostOrderIterator.next()
Node	Node.PreOrderIterator.next()
Node	Node.removeComment()
final Node	Node.setBlockComment(String comment)	Use this to store additional information to this node.
Node	Node.setComment(Comment comment)	Use this to store additional information to this node.
final Node	Node.setLineComment(String comment)	Use this to store additional information to this node.
Node	Node.setParentNode(Node newParentNode)	Assign a new parent to this node, removing it from the list of children of the previous parent, if any.
Node	Node.setParsed(Node.Parsedness parsed)	Used by the parser to flag unparsable nodes.
Node	Node.setRange(Range range)
Node	Node.setTokenRange(TokenRange tokenRange)

Methods in com.github.javaparser.ast that return types with arguments of type Node

Modifier and Type	Method	Description
Optional<Node>	Node.findByRange(Range range)
List<Node>	Node.getChildNodes()	Contains all nodes that have this node set as their parent.
Optional<Node>	Node.getParentNode()
Optional<Node>	NodeList.getParentNode()
Stream<Node>	Node.stream()	Make a stream of nodes using pre-order traversal.
Stream<Node>	Node.stream(Node.TreeTraversal traversal)	Make a stream of nodes using traversal algorithm "traversal".
private Iterable<Node>	Node.treeIterable(Node.TreeTraversal traversal)
private Iterator<Node>	Node.treeIterator(Node.TreeTraversal traversal)

Methods in com.github.javaparser.ast with parameters of type Node

Modifier and Type	Method	Description
private boolean	Node.inPhantomNode(Node node, int levels)	A node contained in a phantom node is also a phantom node.
boolean	Node.isAncestorOf(Node descendant)	Determines whether this node is an ancestor of the given node.
private boolean	Node.isPhantom(Node node)
static <X extends Node> NodeList<X>	NodeList.nodeList(X... nodes)
private void	NodeList.notifyElementAdded(int index, Node nodeAddedOrRemoved)
private void	NodeList.notifyElementRemoved(int index, Node nodeAddedOrRemoved)
private void	NodeList.notifyElementReplaced(int index, Node nodeAddedOrRemoved)
boolean	ArrayCreationLevel.remove(Node node)
boolean	CompilationUnit.remove(Node node)
boolean	Node.remove(Node node)
boolean	NodeList.remove(Node node)
boolean	PackageDeclaration.remove(Node node)
boolean	ArrayCreationLevel.replace(Node node, Node replacementNode)
boolean	CompilationUnit.replace(Node node, Node replacementNode)
boolean	ImportDeclaration.replace(Node node, Node replacementNode)
boolean	Node.replace(Node node)	Try to replace this node in the parent with the supplied node.
boolean	Node.replace(Node node, Node replacementNode)
boolean	PackageDeclaration.replace(Node node, Node replacementNode)
protected void	Node.setAsParentNodeOf(Node childNode)
private void	NodeList.setAsParentNodeOf(Node childNode)
Node	Node.setParentNode(Node newParentNode)	Assign a new parent to this node, removing it from the list of children of the previous parent, if any.
NodeList<N>	NodeList.setParentNode(Node parentNode)	Sets the parentNode

Method parameters in com.github.javaparser.ast with type arguments of type Node

Modifier and Type	Method	Description
<T> Optional<T>	Node.findFirst(Node.TreeTraversal traversal, Function<Node, Optional<T>> consumer)	Walks the AST, applying the function for every node, with traversal algorithm "traversal".
protected void	Node.setAsParentNodeOf(NodeList<? extends Node> list)
private void	NodeList.setAsParentNodeOf(List<? extends Node> childNodes)
void	Node.walk(Node.TreeTraversal traversal, Consumer<Node> consumer)	Walks the AST, calling the consumer for every node, with traversal algorithm "traversal".
void	Node.walk(Consumer<Node> consumer)	Walks the AST, calling the consumer for every node with pre-order traversal.

Constructors in com.github.javaparser.ast with parameters of type Node

Modifier	Constructor	Description
	BreadthFirstIterator(Node node)
	DirectChildrenIterator(Node node)
	NodeList(N... n)
	ParentsVisitor(Node node)
	PostOrderIterator(Node root)
	PreOrderIterator(Node node)

Constructor parameters in com.github.javaparser.ast with type arguments of type Node

Modifier	Constructor	Description
	Level(List<Node> nodes)

Uses of Node in com.github.javaparser.ast.body

Subclasses of Node in com.github.javaparser.ast.body

Modifier and Type	Class	Description
class	AnnotationDeclaration	An annotation type declaration. @interface X { ... }
class	AnnotationMemberDeclaration	The "int id();" in @interface X { int id(); }
class	BodyDeclaration<T extends BodyDeclaration<?>>	Any declaration that can appear between the { and } of a class, interface, enum, or record.
class	CallableDeclaration<T extends CallableDeclaration<?>>	Represents a declaration which is callable eg.
class	ClassOrInterfaceDeclaration	A definition of a class or interface. class X { ... } interface X { ... }
class	CompactConstructorDeclaration	The record declaration's constructor
class	ConstructorDeclaration	A constructor declaration: class X { X() { } } where X(){} is the constructor declaration.
class	EnumConstantDeclaration	One of the values an enum can take.
class	EnumDeclaration	The declaration of an enum. enum X { ... }
class	FieldDeclaration	The declaration of a field in a class.
class	InitializerDeclaration	A (possibly static) initializer body.
class	MethodDeclaration	A method declaration.
class	Parameter	The parameters to a method or lambda.
class	ReceiverParameter	The receiver parameter feature of Java.
class	RecordDeclaration	The record declaration
class	TypeDeclaration<T extends TypeDeclaration<?>>	A base class for all types of type declarations.
class	VariableDeclarator	The declaration of a variable. In int x = 14, y = 3; "int x = 14" and "int y = 3" are VariableDeclarators.

Methods in com.github.javaparser.ast.body with parameters of type Node

Modifier and Type	Method	Description
boolean	AnnotationMemberDeclaration.remove(Node node)
boolean	BodyDeclaration.remove(Node node)
boolean	CallableDeclaration.remove(Node node)
boolean	ClassOrInterfaceDeclaration.remove(Node node)
boolean	CompactConstructorDeclaration.remove(Node node)
boolean	EnumConstantDeclaration.remove(Node node)
boolean	EnumDeclaration.remove(Node node)
boolean	FieldDeclaration.remove(Node node)
boolean	MethodDeclaration.remove(Node node)
boolean	Parameter.remove(Node node)
boolean	ReceiverParameter.remove(Node node)
boolean	RecordDeclaration.remove(Node node)
boolean	TypeDeclaration.remove(Node node)
boolean	VariableDeclarator.remove(Node node)
boolean	AnnotationMemberDeclaration.replace(Node node, Node replacementNode)
boolean	BodyDeclaration.replace(Node node, Node replacementNode)
boolean	CallableDeclaration.replace(Node node, Node replacementNode)
boolean	ClassOrInterfaceDeclaration.replace(Node node, Node replacementNode)
boolean	CompactConstructorDeclaration.replace(Node node, Node replacementNode)
boolean	ConstructorDeclaration.replace(Node node, Node replacementNode)
boolean	EnumConstantDeclaration.replace(Node node, Node replacementNode)
boolean	EnumDeclaration.replace(Node node, Node replacementNode)
boolean	FieldDeclaration.replace(Node node, Node replacementNode)
boolean	InitializerDeclaration.replace(Node node, Node replacementNode)
boolean	MethodDeclaration.replace(Node node, Node replacementNode)
boolean	Parameter.replace(Node node, Node replacementNode)
boolean	ReceiverParameter.replace(Node node, Node replacementNode)
boolean	RecordDeclaration.replace(Node node, Node replacementNode)
boolean	TypeDeclaration.replace(Node node, Node replacementNode)
boolean	VariableDeclarator.replace(Node node, Node replacementNode)

Uses of Node in com.github.javaparser.ast.comments

Subclasses of Node in com.github.javaparser.ast.comments

Modifier and Type	Class	Description
class	BlockComment	AST node that represent block comments.
class	Comment	Abstract class for all AST nodes that represent comments.
class	JavadocComment
class	LineComment	AST node that represent line comments.
class	MarkdownComment	https://openjdk.org/jeps/467 added support for markdown JavaDoc comments /// That are prefixed with /// /// Support `markdown` markup and references /// And supports substrings not allowed in regular block comments, e.g.
class	TraditionalJavadocComment	A Javadoc comment.

Fields in com.github.javaparser.ast.comments declared as Node

Modifier and Type	Field	Description
private Node	Comment.commentedNode

Methods in com.github.javaparser.ast.comments that return Node

Modifier and Type	Method	Description
Node	Comment.findRootNode()
Node	Comment.setComment(Comment comment)

Methods in com.github.javaparser.ast.comments that return types with arguments of type Node

Modifier and Type	Method	Description
Optional<Node>	Comment.getCommentedNode()

Methods in com.github.javaparser.ast.comments with parameters of type Node

Modifier and Type	Method	Description
Comment	Comment.setCommentedNode(Node commentedNode)	Sets the commentedNode

Uses of Node in com.github.javaparser.ast.expr

Subclasses of Node in com.github.javaparser.ast.expr

Modifier and Type	Class	Description
class	AnnotationExpr	A base class for the different types of annotations.
class	ArrayAccessExpr	Array brackets [] being used to get a value from an array.
class	ArrayCreationExpr	new int[5][4][][] or new int[][]{{1},{2,3}}.
class	ArrayInitializerExpr	The initialization of an array.
class	AssignExpr	An assignment expression.
class	BinaryExpr	An expression with an expression on the left, an expression on the right, and an operator in the middle.
class	BooleanLiteralExpr	The boolean literals.
class	CastExpr	A typecast.
class	CharLiteralExpr	A literal character.
class	ClassExpr	Defines an expression that accesses the class of a type.
class	ComponentPatternExpr	Pattern Matching in Java
class	ConditionalExpr	The ternary conditional expression.
class	DoubleLiteralExpr	A float or a double constant.
class	EnclosedExpr	An expression between ( ).
class	Expression	A base class for all expressions.
class	FieldAccessExpr	Access of a field of an object or a class.
class	InstanceOfExpr	The instanceof statement
class	IntegerLiteralExpr	All ways to specify an int literal.
class	LambdaExpr	A lambda expression
class	LiteralExpr	A base class for all literal expressions.
class	LiteralStringValueExpr	Any literal value that is stored internally as a String.
class	LongLiteralExpr	All ways to specify a long literal.
class	MarkerAnnotationExpr	An annotation that uses only the annotation type name.
class	MatchAllPatternExpr	MatchAllPatternExpressions were added in JEP456.
class	MemberValuePair	A value for a member of an annotation.
class	MethodCallExpr	A method call on an object or a class.
class	MethodReferenceExpr	Method reference expressions introduced in Java 8 specifically designed to simplify lambda Expressions.
class	Name	A name that may consist of multiple identifiers.
class	NameExpr	Whenever a SimpleName is used in an expression, it is wrapped in NameExpr.
class	NormalAnnotationExpr	An annotation that has one or more key-value pairs. @Mapping(a=5, d=10)
class	NullLiteralExpr	A literal "null".
class	ObjectCreationExpr	A constructor call.
class	PatternExpr	PatternExpr serves as the abstract base class for typed pattern expressions.
class	RecordPatternExpr	Record Patterns
class	SimpleName	A name that consists of a single identifier.
class	SingleMemberAnnotationExpr	An annotation that has a single value.
class	StringLiteralExpr	A literal string.
class	SuperExpr	An occurrence of the "super" keyword.
class	SwitchExpr	The switch expression
class	TextBlockLiteralExpr	A text block
class	ThisExpr	An occurrence of the "this" keyword.
class	TypeExpr	This class is just instantiated as scopes for MethodReferenceExpr nodes to encapsulate Types.
class	TypePatternExpr	The instanceof statement
class	UnaryExpr	An expression where an operator is applied to a single expression.
class	VariableDeclarationExpr	A declaration of variables.

Fields in com.github.javaparser.ast.expr with type parameters of type Node

Modifier and Type	Field	Description
static final Predicate<Node>	Expression.IS_NOT_ENCLOSED_EXPR	Returns true when the Node to be tested is not an EnclosedExpr, false otherwise.

Methods in com.github.javaparser.ast.expr with parameters of type Node

Modifier and Type	Method	Description
boolean	ArrayCreationExpr.remove(Node node)
boolean	ArrayInitializerExpr.remove(Node node)
boolean	FieldAccessExpr.remove(Node node)
boolean	InstanceOfExpr.remove(Node node)
boolean	LambdaExpr.remove(Node node)
boolean	MatchAllPatternExpr.remove(Node node)
boolean	MethodCallExpr.remove(Node node)
boolean	MethodReferenceExpr.remove(Node node)
boolean	Name.remove(Node node)
boolean	NormalAnnotationExpr.remove(Node node)
boolean	ObjectCreationExpr.remove(Node node)
boolean	RecordPatternExpr.remove(Node node)
boolean	SuperExpr.remove(Node node)
boolean	SwitchExpr.remove(Node node)
boolean	ThisExpr.remove(Node node)
boolean	TypePatternExpr.remove(Node node)
boolean	VariableDeclarationExpr.remove(Node node)
boolean	AnnotationExpr.replace(Node node, Node replacementNode)
boolean	ArrayAccessExpr.replace(Node node, Node replacementNode)
boolean	ArrayCreationExpr.replace(Node node, Node replacementNode)
boolean	ArrayInitializerExpr.replace(Node node, Node replacementNode)
boolean	AssignExpr.replace(Node node, Node replacementNode)
boolean	BinaryExpr.replace(Node node, Node replacementNode)
boolean	CastExpr.replace(Node node, Node replacementNode)
boolean	ClassExpr.replace(Node node, Node replacementNode)
boolean	ConditionalExpr.replace(Node node, Node replacementNode)
boolean	EnclosedExpr.replace(Node node, Node replacementNode)
boolean	FieldAccessExpr.replace(Node node, Node replacementNode)
boolean	InstanceOfExpr.replace(Node node, Node replacementNode)
boolean	LambdaExpr.replace(Node node, Node replacementNode)
boolean	MatchAllPatternExpr.replace(Node node, Node replacementNode)
boolean	MemberValuePair.replace(Node node, Node replacementNode)
boolean	MethodCallExpr.replace(Node node, Node replacementNode)
boolean	MethodReferenceExpr.replace(Node node, Node replacementNode)
boolean	Name.replace(Node node, Node replacementNode)
boolean	NameExpr.replace(Node node, Node replacementNode)
boolean	NormalAnnotationExpr.replace(Node node, Node replacementNode)
boolean	ObjectCreationExpr.replace(Node node, Node replacementNode)
boolean	PatternExpr.replace(Node node, Node replacementNode)
boolean	RecordPatternExpr.replace(Node node, Node replacementNode)
boolean	SingleMemberAnnotationExpr.replace(Node node, Node replacementNode)
boolean	SuperExpr.replace(Node node, Node replacementNode)
boolean	SwitchExpr.replace(Node node, Node replacementNode)
boolean	ThisExpr.replace(Node node, Node replacementNode)
boolean	TypeExpr.replace(Node node, Node replacementNode)
boolean	TypePatternExpr.replace(Node node, Node replacementNode)
boolean	UnaryExpr.replace(Node node, Node replacementNode)
boolean	VariableDeclarationExpr.replace(Node node, Node replacementNode)

Uses of Node in com.github.javaparser.ast.modules

Subclasses of Node in com.github.javaparser.ast.modules

Modifier and Type	Class	Description
class	ModuleDeclaration	A Java 9 Jigsaw module declaration.
class	ModuleDirective	A module directive.
class	ModuleExportsDirective	An exports directive in module-info.java.
class	ModuleOpensDirective	An opens directive in module-info.java.
class	ModuleProvidesDirective	A provides directive in module-info.java.
class	ModuleRequiresDirective	A require directive in module-info.java.
class	ModuleUsesDirective	A uses directive in module-info.java.

Methods in com.github.javaparser.ast.modules with parameters of type Node

Modifier and Type	Method	Description
boolean	ModuleDeclaration.remove(Node node)
boolean	ModuleExportsDirective.remove(Node node)
boolean	ModuleOpensDirective.remove(Node node)
boolean	ModuleProvidesDirective.remove(Node node)
boolean	ModuleRequiresDirective.remove(Node node)
boolean	ModuleDeclaration.replace(Node node, Node replacementNode)
boolean	ModuleExportsDirective.replace(Node node, Node replacementNode)
boolean	ModuleOpensDirective.replace(Node node, Node replacementNode)
boolean	ModuleProvidesDirective.replace(Node node, Node replacementNode)
boolean	ModuleRequiresDirective.replace(Node node, Node replacementNode)
boolean	ModuleUsesDirective.replace(Node node, Node replacementNode)

Uses of Node in com.github.javaparser.ast.nodeTypes

Classes in com.github.javaparser.ast.nodeTypes with type parameters of type Node

Modifier and Type	Interface	Description
interface	NodeWithAnnotations<N extends Node>	A node that can be annotated.
interface	NodeWithArguments<N extends Node>	A node with arguments.
interface	NodeWithBlockStmt<N extends Node>	A node with a body that is a BlockStmt.
interface	NodeWithBody<N extends Node>
interface	NodeWithCondition<N extends Node>
interface	NodeWithExpression<N extends Node>	A node that has an expression in it.
interface	NodeWithExtends<N extends Node>	A node that explicitly extends other types, using the extends keyword.
interface	NodeWithIdentifier<N extends Node>
interface	NodeWithImplements<N extends Node>	A node that implements other types.
interface	NodeWithJavadoc<N extends Node>	A node that can be documented with a Javadoc comment.
interface	NodeWithMembers<N extends Node>	A node having members.
interface	NodeWithModifiers<N extends Node>	A Node with Modifiers.
interface	NodeWithName<N extends Node>	A node with a (qualified) name.
interface	NodeWithOptionalBlockStmt<N extends Node>	A node with a body that is a BlockStmt, which is optional.
interface	NodeWithOptionalLabel<T extends Node>	A node that has an optional label.
interface	NodeWithOptionalScope<N extends Node>	Represents a node which has an optional scope expression eg.
interface	NodeWithParameters<N extends Node>
interface	NodeWithScope<N extends Node>	Represents a node which has a required scope expression eg.
interface	NodeWithSimpleName<N extends Node>	A node with a name.
interface	NodeWithStatements<N extends Node>	A node that contains a list of statements.
interface	NodeWithThrownExceptions<N extends Node>	A node that declares the types of exception it throws.
interface	NodeWithType<N extends Node, T extends Type>	A node with a type.
interface	NodeWithTypeArguments<N extends Node>	A node that can have type arguments.
interface	NodeWithTypeParameters<N extends Node>	A node that can have type parameters.
interface	NodeWithVariables<N extends Node>	A node which has a list of variables.

Methods in com.github.javaparser.ast.nodeTypes that return Node

Modifier and Type	Method	Description
Node	NodeWithJavadoc.setComment(Comment comment)

Methods in com.github.javaparser.ast.nodeTypes with parameters of type Node

Modifier and Type	Method	Description
default boolean	NodeWithRange.containsWithin(Node other)	Deprecated. use NodeWithRange.containsWithinRange(Node) instead.
default boolean	NodeWithRange.containsWithinRange(Node other)	Checks whether the range of the given Node is contained within the range of this NodeWithRange.
boolean	SwitchNode.remove(Node node)
boolean	SwitchNode.replace(Node node, Node replacementNode)

Uses of Node in com.github.javaparser.ast.nodeTypes.modifiers

Classes in com.github.javaparser.ast.nodeTypes.modifiers with type parameters of type Node

Modifier and Type	Interface	Description
interface	NodeWithAbstractModifier<N extends Node>	A node that can be abstract.
interface	NodeWithAccessModifiers<N extends Node>	A node that can be public, protected, and/or private.
interface	NodeWithFinalModifier<N extends Node>	A node that can be final.
interface	NodeWithPrivateModifier<N extends Node>	A node that can be private.
interface	NodeWithProtectedModifier<N extends Node>	A node that can be protected.
interface	NodeWithPublicModifier<N extends Node>	A node that can be public.
interface	NodeWithStaticModifier<N extends Node>	A node that can be static.
interface	NodeWithStrictfpModifier<N extends Node>	A node that can be strictfp.

Uses of Node in com.github.javaparser.ast.observer

Methods in com.github.javaparser.ast.observer that return Node

Modifier and Type	Method	Description
Node	ObservableProperty.getValueAsSingleReference(Node node)

Methods in com.github.javaparser.ast.observer that return types with arguments of type Node

Modifier and Type	Method	Description
NodeList<? extends Node>	ObservableProperty.getValueAsMultipleReference(Node node)

Methods in com.github.javaparser.ast.observer with parameters of type Node

Modifier and Type	Method	Description
void	PropagatingAstObserver.concreteListChange(NodeList<?> observedNode, AstObserver.ListChangeType type, int index, Node nodeAddedOrRemoved)
void	PropagatingAstObserver.concreteListReplacement(NodeList<?> observedNode, int index, Node oldValue, Node newValue)
void	PropagatingAstObserver.concretePropertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue)
Object	ObservableProperty.getRawValue(Node node)
Boolean	ObservableProperty.getValueAsBooleanAttribute(Node node)
Collection<?>	ObservableProperty.getValueAsCollection(Node node)
NodeList<? extends Node>	ObservableProperty.getValueAsMultipleReference(Node node)
Node	ObservableProperty.getValueAsSingleReference(Node node)
String	ObservableProperty.getValueAsStringAttribute(Node node)
private boolean	ObservableProperty.hasMethod(Node node, String name)
boolean	ObservableProperty.isNull(Node node)
boolean	ObservableProperty.isNullOrEmpty(Node node)
boolean	ObservableProperty.isNullOrNotPresent(Node node)
void	AstObserver.listChange(NodeList<?> observedNode, AstObserver.ListChangeType type, int index, Node nodeAddedOrRemoved)	A list is changed
void	AstObserverAdapter.listChange(NodeList<?> observedNode, AstObserver.ListChangeType type, int index, Node nodeAddedOrRemoved)
final void	PropagatingAstObserver.listChange(NodeList<?> observedNode, AstObserver.ListChangeType type, int index, Node nodeAddedOrRemoved)
void	AstObserver.listReplacement(NodeList<?> observedNode, int index, Node oldNode, Node newNode)
void	AstObserverAdapter.listReplacement(NodeList<?> observedNode, int index, Node oldNode, Node newNode)
void	PropagatingAstObserver.listReplacement(NodeList<?> observedNode, int index, Node oldNode, Node newNode)
void	AstObserver.parentChange(Node observedNode, Node previousParent, Node newParent)	The parent of a node is changed
void	AstObserverAdapter.parentChange(Node observedNode, Node previousParent, Node newParent)
void	PropagatingAstObserver.parentChange(Node observedNode, Node previousParent, Node newParent)
void	AstObserver.propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue)	The value of a property is changed
void	AstObserverAdapter.propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue)
final void	PropagatingAstObserver.propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue)

Uses of Node in com.github.javaparser.ast.stmt

Subclasses of Node in com.github.javaparser.ast.stmt

Modifier and Type	Class	Description
class	AssertStmt	A usage of the keyword "assert" In assert dead : "Wasn't expecting to be dead here"; the check is "dead" and the message is the string.
class	BlockStmt	Statements in between { and }.
class	BreakStmt	The break statement
class	CatchClause	The catch part of a try-catch-finally.
class	ContinueStmt	A continue statement with an optional label; continue brains; continue;
class	DoStmt	A do-while.
class	EmptyStmt	An empty statement is a ";" where a statement is expected.
class	ExplicitConstructorInvocationStmt	A call to super or this in a constructor or initializer.
class	ExpressionStmt	Used to wrap an expression so that it can take the place of a statement.
class	ForEachStmt	A for-each statement.
class	ForStmt	The classic for statement
class	IfStmt	An if-then-else statement.
class	LabeledStmt	A statement that is labeled, like label123: println("continuing");
class	LocalClassDeclarationStmt	A class declaration inside a method.
class	LocalRecordDeclarationStmt	A record declaration inside a method.
class	ReturnStmt	The return statement, with an optional expression to return.
class	Statement	A base class for all statements.
class	SwitchEntry	One case in a switch statement
class	SwitchStmt	The switch statement
class	SynchronizedStmt	Usage of the synchronized keyword.
class	ThrowStmt	Usage of the throw statement.
class	TryStmt	The try statement
class	UnparsableStmt	A statement that had parse errors.
class	WhileStmt	A while statement.
class	YieldStmt	The yield statement

Methods in com.github.javaparser.ast.stmt with parameters of type Node

Modifier and Type	Method	Description
boolean	AssertStmt.remove(Node node)
boolean	BlockStmt.remove(Node node)
boolean	BreakStmt.remove(Node node)
boolean	ContinueStmt.remove(Node node)
boolean	ExplicitConstructorInvocationStmt.remove(Node node)
boolean	ForStmt.remove(Node node)
boolean	IfStmt.remove(Node node)
boolean	ReturnStmt.remove(Node node)
boolean	SwitchEntry.remove(Node node)
boolean	SwitchStmt.remove(Node node)
boolean	TryStmt.remove(Node node)
boolean	AssertStmt.replace(Node node, Node replacementNode)
boolean	BlockStmt.replace(Node node, Node replacementNode)
boolean	BreakStmt.replace(Node node, Node replacementNode)
boolean	CatchClause.replace(Node node, Node replacementNode)
boolean	ContinueStmt.replace(Node node, Node replacementNode)
boolean	DoStmt.replace(Node node, Node replacementNode)
boolean	ExplicitConstructorInvocationStmt.replace(Node node, Node replacementNode)
boolean	ExpressionStmt.replace(Node node, Node replacementNode)
boolean	ForEachStmt.replace(Node node, Node replacementNode)
boolean	ForStmt.replace(Node node, Node replacementNode)
boolean	IfStmt.replace(Node node, Node replacementNode)
boolean	LabeledStmt.replace(Node node, Node replacementNode)
boolean	LocalClassDeclarationStmt.replace(Node node, Node replacementNode)
boolean	LocalRecordDeclarationStmt.replace(Node node, Node replacementNode)
boolean	ReturnStmt.replace(Node node, Node replacementNode)
boolean	SwitchEntry.replace(Node node, Node replacementNode)
boolean	SwitchStmt.replace(Node node, Node replacementNode)
boolean	SynchronizedStmt.replace(Node node, Node replacementNode)
boolean	ThrowStmt.replace(Node node, Node replacementNode)
boolean	TryStmt.replace(Node node, Node replacementNode)
boolean	WhileStmt.replace(Node node, Node replacementNode)
boolean	YieldStmt.replace(Node node, Node replacementNode)

Uses of Node in com.github.javaparser.ast.type

Subclasses of Node in com.github.javaparser.ast.type

Modifier and Type	Class	Description
class	ArrayType	To indicate that a type is an array, it gets wrapped in an ArrayType for every array level it has.
class	ClassOrInterfaceType	A class or an interface type.
class	IntersectionType	Represents a set of types.
class	PrimitiveType	A primitive type.
class	ReferenceType	Base class for reference types.
class	Type	Base class for types.
class	TypeParameter	A type parameter.
class	UnionType	The union type
class	UnknownType	An unknown parameter type object.
class	VarType	A type called "var" waiting for Java to infer it.
class	VoidType	The return type of a MethodDeclaration when it returns void.
class	WildcardType	A wildcard type argument.

Methods in com.github.javaparser.ast.type with parameters of type Node

Modifier and Type	Method	Description
boolean	ClassOrInterfaceType.remove(Node node)
boolean	IntersectionType.remove(Node node)
boolean	Type.remove(Node node)
boolean	TypeParameter.remove(Node node)
boolean	UnionType.remove(Node node)
boolean	WildcardType.remove(Node node)
boolean	ArrayType.replace(Node node, Node replacementNode)
boolean	ClassOrInterfaceType.replace(Node node, Node replacementNode)
boolean	IntersectionType.replace(Node node, Node replacementNode)
boolean	Type.replace(Node node, Node replacementNode)
boolean	TypeParameter.replace(Node node, Node replacementNode)
boolean	UnionType.replace(Node node, Node replacementNode)
boolean	WildcardType.replace(Node node, Node replacementNode)

Uses of Node in com.github.javaparser.ast.validator

Classes in com.github.javaparser.ast.validator with type parameters of type Node

Modifier and Type	Class	Description
class	SimpleValidator<N extends Node>	Runs a validator on all nodes of a certain type, and adds a problem for all nodes that pass a condition.
class	SingleNodeTypeValidator<N extends Node>	Runs a validator on all nodes of a certain type.
interface	TypedValidator<N extends Node>	A validator that validates a known node type.

Subinterfaces with type arguments of type Node in com.github.javaparser.ast.validator

Modifier and Type	Interface	Description
interface	Validator	A validator that can be run on a node to check for semantic errors.

Methods in com.github.javaparser.ast.validator with parameters of type Node

Modifier and Type	Method	Description
void	SingleNodeTypeValidator.accept(Node node, ProblemReporter problemReporter)
final void	TreeVisitorValidator.accept(Node node, ProblemReporter reporter)
void	Validator.accept(Node node, ProblemReporter problemReporter)
void	Validators.accept(Node node, ProblemReporter problemReporter)
void	VisitorValidator.accept(Node node, ProblemReporter problemReporter)
private boolean	RecordAsTypeIdentifierNotAllowed.validUsage(Node node)

Uses of Node in com.github.javaparser.ast.validator.language_level_validations

Methods in com.github.javaparser.ast.validator.language_level_validations with parameters of type Node

Modifier and Type	Method	Description
private boolean	Java22Validator.reportNoParent(Node node, ProblemReporter reporter)

Uses of Node in com.github.javaparser.ast.validator.language_level_validations.chunks

Methods in com.github.javaparser.ast.validator.language_level_validations.chunks with parameters of type Node

Modifier and Type	Method	Description
private static void	UnderscoreKeywordValidator.validateIdentifier(Node n, String id, ProblemReporter arg)

Uses of Node in com.github.javaparser.ast.validator.postprocessors

Method parameters in com.github.javaparser.ast.validator.postprocessors with type arguments of type Node

Modifier and Type	Method	Description
void	PostProcessors.postProcess(ParseResult<? extends Node> result, ParserConfiguration configuration)

Uses of Node in com.github.javaparser.ast.visitor

Fields in com.github.javaparser.ast.visitor declared as Node

Modifier and Type	Field	Description
private Node	NodeFinderVisitor.selectedNode

Fields in com.github.javaparser.ast.visitor with type parameters of type Node

Modifier and Type	Field	Description
static BiFunction<Node,Range,Boolean>	NodeFinderVisitor.fConveringNode
private static BiFunction<Node,Range,Boolean>	NodeFinderVisitor.fn

Methods in com.github.javaparser.ast.visitor with type parameters of type Node

Modifier and Type	Method	Description
private <N extends Node> NodeList<N>	CloneVisitor.cloneList(NodeList<N> list, Object arg)
protected <T extends Node> T	CloneVisitor.cloneNode(Optional<T> node, Object arg)
protected <T extends Node> T	CloneVisitor.cloneNode(T node, Object arg)
private <N extends Node> NodeList<N>	ModifierVisitor.modifyList(NodeList<N> list, A arg)
private <N extends Node> NodeList<N>	ModifierVisitor.modifyList(Optional<NodeList<N>> list, A arg)
private <T extends Node> boolean	EqualsVisitor.nodeEquals(Optional<T> n, Optional<T> n2)
private <T extends Node> boolean	EqualsVisitor.nodeEquals(T n, T n2)
private <T extends Node> boolean	NoCommentEqualsVisitor.nodeEquals(Optional<T> n, Optional<T> n2)
private <T extends Node> boolean	NoCommentEqualsVisitor.nodeEquals(T n, T n2)
private <N extends Node> boolean	EqualsVisitor.nodesEquals(NodeList<N> n, NodeList<N> n2)
private <T extends Node> boolean	EqualsVisitor.nodesEquals(List<T> nodes1, List<T> nodes2)
private <T extends Node> boolean	EqualsVisitor.nodesEquals(Optional<NodeList<T>> n, Optional<NodeList<T>> n2)
private <N extends Node> boolean	NoCommentEqualsVisitor.nodesEquals(NodeList<N> n, NodeList<N> n2)
private <T extends Node> boolean	NoCommentEqualsVisitor.nodesEquals(Optional<NodeList<T>> n, Optional<NodeList<T>> n2)

Methods in com.github.javaparser.ast.visitor that return Node

Modifier and Type	Method	Description
Node	NodeFinderVisitor.getSelectedNode()	Returns the covering node.
Node	CloneVisitor.visit(ImportDeclaration n, Object arg)
Node	ModifierVisitor.visit(ImportDeclaration n, A arg)

Methods in com.github.javaparser.ast.visitor with parameters of type Node

Modifier and Type	Method	Description
private boolean	EqualsVisitor.commonNodeEquality(Node n, Node n2)	Check for equality that can be applied to each kind of node, to not repeat it in every method we store that here.
private void	CloneVisitor.copyData(Node source, Node destination)
R	GenericVisitorWithDefaults.defaultAction(Node n, A arg)	This will be called by every node visit method that is not overridden.
void	VoidVisitorWithDefaults.defaultAction(Node n, A arg)	This will be called by every node visit method that is not overridden.
static boolean	EqualsVisitor.equals(Node n, Node n2)
static boolean	NoCommentEqualsVisitor.equals(Node n, Node n2)
static boolean	ObjectIdentityEqualsVisitor.equals(Node n, Node n2)
static int	HashCodeVisitor.hashCode(Node node)
static int	NoCommentHashCodeVisitor.hashCode(Node node)
static int	ObjectIdentityHashCodeVisitor.hashCode(Node node)
abstract void	TreeVisitor.process(Node node)	Process the given node.
void	TreeVisitor.visitBreadthFirst(Node node)	https://en.wikipedia.org/wiki/Breadth-first_search
void	TreeVisitor.visitDirectChildren(Node node)	Performs a simple traversal over all nodes that have the passed node as their parent.
void	TreeVisitor.visitLeavesFirst(Node node)
void	TreeVisitor.visitPostOrder(Node node)	Performs a post-order node traversal starting with a given node.
void	TreeVisitor.visitPreOrder(Node node)	Performs a pre-order node traversal starting with a given node.

Constructor parameters in com.github.javaparser.ast.visitor with type arguments of type Node

Modifier	Constructor	Description
	NodeFinderVisitor(BiFunction<Node,Range,Boolean> fn)

Uses of Node in com.github.javaparser.metamodel

Fields in com.github.javaparser.metamodel with type parameters of type Node

Modifier and Type	Field	Description
private final Class<? extends Node>	BaseNodeMetaModel.type

Methods in com.github.javaparser.metamodel that return Node

Modifier and Type	Method	Description
Node	BaseNodeMetaModel.construct(Map<String,Object> parameters)	Creates a new node of this type.

Methods in com.github.javaparser.metamodel that return types with arguments of type Node

Modifier and Type	Method	Description
Class<? extends Node>	BaseNodeMetaModel.getType()

Methods in com.github.javaparser.metamodel with parameters of type Node

Modifier and Type	Method	Description
Object	PropertyMetaModel.getValue(Node node)	Introspects the node to get the value from this field.

Method parameters in com.github.javaparser.metamodel with type arguments of type Node

Modifier and Type	Method	Description
boolean	BaseNodeMetaModel.is(Class<? extends Node> c)
boolean	PropertyMetaModel.is(Class<? extends Node> c, String fieldName)

Constructor parameters in com.github.javaparser.metamodel with type arguments of type Node

Modifier	Constructor	Description
protected	AnnotationExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
	BaseNodeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	BodyDeclarationMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	CallableDeclarationMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	CommentMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	ComponentPatternExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	ExpressionMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	JavadocCommentMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	LiteralExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	LiteralStringValueExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	ModuleDirectiveMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	NodeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	PatternExprMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	ReferenceTypeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	StatementMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	TypeDeclarationMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)
protected	TypeMetaModel(Optional<BaseNodeMetaModel> superNodeMetaModel, Class<? extends Node> type, String name, String packageName, boolean isAbstract, boolean hasWildcard)

Uses of Node in com.github.javaparser.printer

Methods in com.github.javaparser.printer with parameters of type Node

Modifier and Type	Method	Description
static String	ConcreteSyntaxModel.genericPrettyPrint(Node node)
static void	ConcreteSyntaxModel.genericPrettyPrint(Node node, SourcePrinter printer)
String	DotPrinter.output(Node node)
void	DotPrinter.output(Node node, String parentNodeName, String name, StringBuilder builder)
String	XmlPrinter.output(Node node)	Generate a xml string for given AST Node.
void	XmlPrinter.output(Node node, String name, int level, StringBuilder builder)	Deprecated.
String	YamlPrinter.output(Node node)
void	YamlPrinter.output(Node node, String name, int level, StringBuilder builder)
void	XmlPrinter.outputDocument(Node node, String name, Writer writer)	Output the XML Document representing given AST node to given writer.
void	XmlPrinter.outputDocument(Node node, String name, XMLStreamWriter xmlWriter)	Output the XML Document representing an AST node to given XMLStreamWriter.
void	XmlPrinter.outputNode(Node node, String name, XMLStreamWriter xmlWriter)	Output the XML Element representing an AST node to given writer.
String	DefaultPrettyPrinter.print(Node node)
String	PrettyPrinter.print(Node node)	Deprecated.
String	Printer.print(Node node)
static void	XmlPrinter.print(Node node)
static void	YamlPrinter.print(Node node)
protected void	DefaultPrettyPrinterVisitor.printOrphanCommentsBeforeThisChildNode(Node node)	Print all orphaned comments coming right before node.
private void	PrettyPrintVisitor.printOrphanCommentsBeforeThisChildNode(Node node)	Deprecated.
protected void	DefaultPrettyPrinterVisitor.printOrphanCommentsEnding(Node node)	Print all orphan comments coming at the end of the given node.
private void	PrettyPrintVisitor.printOrphanCommentsEnding(Node node)	Deprecated.
StringWriter	XmlPrinter.stringWriterOutput(Node node, String name)	Create a string writer filled with XML document representing an AST node.

Method parameters in com.github.javaparser.printer with type arguments of type Node

Modifier and Type	Method	Description
static CsmElement	ConcreteSyntaxModel.forClass(Class<? extends Node> nodeClazz)

Uses of Node in com.github.javaparser.printer.concretesyntaxmodel

Methods in com.github.javaparser.printer.concretesyntaxmodel with parameters of type Node

Modifier and Type	Method	Description
(package private) abstract boolean	CsmConditional.Condition.evaluate(Node node, ObservableProperty property)
int	CsmAttribute.getTokenType(Node node, String text, String tokenText)	Obtain the token type corresponding to the specific value of the attribute.
void	CsmAttribute.prettyPrint(Node node, SourcePrinter printer)
void	CsmChar.prettyPrint(Node node, SourcePrinter printer)
void	CsmComment.prettyPrint(Node node, SourcePrinter printer)
void	CsmConditional.prettyPrint(Node node, SourcePrinter printer)
void	CsmElement.prettyPrint(Node node, SourcePrinter printer)
void	CsmIndent.prettyPrint(Node node, SourcePrinter printer)
void	CsmList.prettyPrint(Node node, SourcePrinter printer)
void	CsmMix.prettyPrint(Node node, SourcePrinter printer)
void	CsmNone.prettyPrint(Node node, SourcePrinter printer)
void	CsmOrphanCommentsEnding.prettyPrint(Node node, SourcePrinter printer)
void	CsmSequence.prettyPrint(Node node, SourcePrinter printer)
void	CsmSingleReference.prettyPrint(Node node, SourcePrinter printer)
void	CsmString.prettyPrint(Node node, SourcePrinter printer)
void	CsmTextBlock.prettyPrint(Node node, SourcePrinter printer)
void	CsmToken.prettyPrint(Node node, SourcePrinter printer)
void	CsmUnindent.prettyPrint(Node node, SourcePrinter printer)

Uses of Node in com.github.javaparser.printer.lexicalpreservation

Fields in com.github.javaparser.printer.lexicalpreservation declared as Node

Modifier and Type	Field	Description
private final Node	ChildTextElement.child
private final Node	LexicalDifferenceCalculator.CsmChild.child
private final Node	Difference.node
(package private) Node	DifferenceElementCalculator.ChildPositionInfo.node

Fields in com.github.javaparser.printer.lexicalpreservation with type parameters of type Node

Modifier and Type	Field	Description
private static final Map<Node,Boolean>	PhantomNodeLogic.isPhantomNodeCache	Deprecated.

Methods in com.github.javaparser.printer.lexicalpreservation with type parameters of type Node

Modifier and Type	Method	Description
static <N extends Node> N	LexicalPreservingPrinter.setup(N node)	Initializes lexical preservation for the given CompilationUnit.

Methods in com.github.javaparser.printer.lexicalpreservation that return Node

Modifier and Type	Method	Description
Node	ChildTextElement.getChild()
Node	LexicalDifferenceCalculator.CsmChild.getChild()
Node	Removed.getChild()

Methods in com.github.javaparser.printer.lexicalpreservation with parameters of type Node

Modifier and Type	Method	Description
(package private) void	NodeText.addChild(int index, Node child)
(package private) void	NodeText.addChild(Node child)
(package private) static TextElementMatcher	TextElementMatchers.byNode(Node node)
(package private) LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelAfterListAddition(Node container, ObservableProperty observableProperty, int index, Node nodeAdded)
(package private) LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelAfterListAddition(CsmElement csm, ObservableProperty observableProperty, NodeList<?> nodeList, int index, Node nodeAdded)
(package private) LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelAfterListRemoval(Node container, ObservableProperty observableProperty, int index)
private LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelAfterListReplacement(CsmElement csm, ObservableProperty observableProperty, NodeList<?> nodeList, int index, Node newValue)
(package private) LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelAfterPropertyChange(Node node, ObservableProperty property, Object oldValue, Object newValue)
(package private) LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelAfterPropertyChange(CsmElement csm, Node node, ObservableProperty property, Object oldValue, Object newValue)
(package private) LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelForNode(Node node)
(package private) LexicalDifferenceCalculator.CalculatedSyntaxModel	LexicalDifferenceCalculator.calculatedSyntaxModelForNode(CsmElement csm, Node node)
private void	LexicalDifferenceCalculator.calculatedSyntaxModelForNode(CsmElement csm, Node node, List<CsmElement> elements, Change change)
(package private) List<DifferenceElement>	LexicalDifferenceCalculator.calculateListAdditionDifference(ObservableProperty observableProperty, NodeList<?> nodeList, int index, Node nodeAdded)
(package private) List<DifferenceElement>	LexicalDifferenceCalculator.calculateListReplacementDifference(ObservableProperty observableProperty, NodeList<?> nodeList, int index, Node newValue)
(package private) void	LexicalDifferenceCalculator.calculatePropertyChange(NodeText nodeText, Node observedNode, ObservableProperty property, Object oldValue, Object newValue)
void	LexicalPreservingPrinter.Observer.concreteListChange(NodeList<?> changedList, AstObserver.ListChangeType type, int index, Node nodeAddedOrRemoved)
void	LexicalPreservingPrinter.Observer.concreteListReplacement(NodeList<?> changedList, int index, Node oldValue, Node newValue)
void	LexicalPreservingPrinter.Observer.concretePropertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue)
(package private) int	NodeText.findChild(Node child)
(package private) int	NodeText.findChild(Node child, int from)
(package private) static List<TextElement>	LexicalPreservingPrinter.findIndentation(Node node)
(package private) static NodeText	LexicalPreservingPrinter.getOrCreateNodeText(Node node)
private static boolean	PhantomNodeLogic.inPhantomNode(Node node, int levels)	Deprecated. A node contained in a phantom node is also a phantom node.
private static NodeText	LexicalPreservingPrinter.interpret(Node node, CsmElement csm, NodeText nodeText)	TODO: Process CsmIndent and CsmUnindent before reaching this point
static boolean	LexicalPreservingPrinter.isAvailableOn(Node node)
boolean	ChildTextElement.isNode(Node node)
(package private) abstract boolean	TextElement.isNode(Node node)
(package private) boolean	TokenTextElement.isNode(Node node)
(package private) static boolean	PhantomNodeLogic.isPhantomNode(Node node)	Deprecated.
void	LexicalDifferenceCalculator.CsmChild.prettyPrint(Node node, SourcePrinter printer)
private static void	LexicalPreservingPrinter.prettyPrintingTextNode(Node node, NodeText nodeText)
String	DefaultLexicalPreservingPrinter.print(Node node)	Print a Node into a String, preserving the lexical information.
static String	LexicalPreservingPrinter.print(Node node)	Prints the given node to a string while preserving the original formatting where possible and applying changes where the AST has been modified.
private static void	LexicalPreservingPrinter.storeInitialText(Node root)	Stores the initial textual representation for all nodes in the AST.
private static void	LexicalPreservingPrinter.storeInitialTextForOneNode(Node node, List<JavaToken> nodeTokens)	Recursively stores initial text representation for all child nodes of the given parent node.
private static Iterator<TokenTextElement>	LexicalPreservingPrinter.tokensPreceeding(Node node)
(package private) int	NodeText.tryToFindChild(Node child)
(package private) int	NodeText.tryToFindChild(Node child, int from)

Method parameters in com.github.javaparser.printer.lexicalpreservation with type arguments of type Node

Modifier and Type	Method	Description
boolean	ChildTextElement.isChildOfClass(Class<? extends Node> nodeClass)
abstract boolean	TextElement.isChildOfClass(Class<? extends Node> nodeClass)	Is this TextElement representing a child of the given class?
boolean	TokenTextElement.isChildOfClass(Class<? extends Node> nodeClass)

Constructors in com.github.javaparser.printer.lexicalpreservation with parameters of type Node

Modifier	Constructor	Description
(package private)	ChildPositionInfo(Node node, Integer position)
(package private)	ChildTextElement(Node child)
(package private)	CsmChild(Node child)
(package private)	Difference(List<DifferenceElement> diffElements, NodeText nodeText, Node node)

Uses of Node in com.github.javaparser.printer.lexicalpreservation.changes

Fields in com.github.javaparser.printer.lexicalpreservation.changes declared as Node

Modifier and Type	Field	Description
private final Node	ListReplacementChange.newValue
private final Node	ListAdditionChange.nodeAdded

Methods in com.github.javaparser.printer.lexicalpreservation.changes with parameters of type Node

Modifier and Type	Method	Description
default boolean	Change.evaluate(CsmConditional csmConditional, Node node)
Object	Change.getValue(ObservableProperty property, Node node)
Object	ListAdditionChange.getValue(ObservableProperty property, Node node)
Object	ListRemovalChange.getValue(ObservableProperty property, Node node)
Object	ListReplacementChange.getValue(ObservableProperty property, Node node)
Object	NoChange.getValue(ObservableProperty property, Node node)
Object	PropertyChange.getValue(ObservableProperty property, Node node)
private boolean	ListRemovalChange.isSameNode(Node n1, Node n2)
private boolean	ListRemovalChange.isSameRange(Node n1, Node n2)

Constructors in com.github.javaparser.printer.lexicalpreservation.changes with parameters of type Node

Modifier	Constructor	Description
	ListAdditionChange(ObservableProperty observableProperty, int index, Node nodeAdded)
	ListReplacementChange(ObservableProperty observableProperty, int index, Node newValue)

Uses of Node in com.github.javaparser.resolution

Methods in com.github.javaparser.resolution with type parameters of type Node

Modifier and Type	Method	Description
static <N extends Node> N	Navigator.demandNodeOfGivenClass(Node node, Class<N> clazz)
static <N extends Node> N	Navigator.findNodeOfGivenClass(Node node, Class<N> clazz)	Deprecated. Use Navigator.demandNodeOfGivenClass(Node, Class)
<N extends Node> N	Context.getWrappedNode()	Returns the node wrapped in the context

Methods in com.github.javaparser.resolution that return Node

Modifier and Type	Method	Description
static Node	Navigator.demandParentNode(Node node)
static Node	Navigator.demandParentNode(Node node, Predicate<Node> isAcceptedParentNode)	Traverses the parent chain starting at node and returns the first Node that returns make isAcceptedParentNode evaluate to true.
static Node	Navigator.requireParentNode(Node node)	Deprecated. Use Navigator.demandParentNode(Node)

Methods in com.github.javaparser.resolution with parameters of type Node

Modifier and Type	Method	Description
static <N extends Node> N	Navigator.demandNodeOfGivenClass(Node node, Class<N> clazz)
static Node	Navigator.demandParentNode(Node node)
static Node	Navigator.demandParentNode(Node node, Predicate<Node> isAcceptedParentNode)	Traverses the parent chain starting at node and returns the first Node that returns make isAcceptedParentNode evaluate to true.
static SwitchStmt	Navigator.demandSwitch(Node node)
static Optional<VariableDeclarator>	Navigator.demandVariableDeclaration(Node node, String name)
default List<ResolvedFieldDeclaration>	Context.fieldsExposedToChild(Node child)	The fields that are declared and in this immediate context made visible to a given child.
static Optional<MethodCallExpr>	Navigator.findMethodCall(Node node, String methodName)
static Optional<NameExpr>	Navigator.findNameExpression(Node node, String name)
static <N extends Node> N	Navigator.findNodeOfGivenClass(Node node, Class<N> clazz)	Deprecated. Use Navigator.demandNodeOfGivenClass(Node, Class)
static Optional<SimpleName>	Navigator.findSimpleName(Node node, String name)
static SwitchStmt	Navigator.findSwitch(Node node)	Deprecated. Use Navigator.demandSwitch(Node)
private static Optional<SwitchStmt>	Navigator.findSwitchHelper(Node node)
default List<VariableDeclarator>	Context.localVariablesExposedToChild(Node child)	The local variables that are declared in this immediate context and made visible to a given child.
default List<Parameter>	Context.parametersExposedToChild(Node child)	The parameters that are declared in this immediate context and made visible to a given child.
static Node	Navigator.requireParentNode(Node node)	Deprecated. Use Navigator.demandParentNode(Node)
<T> T	SymbolResolver.resolveDeclaration(Node node, Class<T> resultClass)	For a reference it would find the corresponding declaration.
MethodUsage	Solver.solveMethod(String methodName, List<ResolvedType> argumentsTypes, Node node)
SymbolReference<? extends ResolvedValueDeclaration>	Solver.solveSymbol(String name, Node node)
Optional<Value>	Solver.solveSymbolAsValue(String name, Node node)
SymbolReference<? extends ResolvedTypeDeclaration>	Solver.solveType(String name, Node node)
ResolvedReferenceTypeDeclaration	SymbolResolver.toTypeDeclaration(Node node)	For a node it would find the corresponding reference type declaration.
default List<TypePatternExpr>	Context.typePatternExprsExposedToChild(Node child)	The pattern expressions that are declared in this immediate context and made visible to a given child.

Method parameters in com.github.javaparser.resolution with type arguments of type Node

Modifier and Type	Method	Description
static Node	Navigator.demandParentNode(Node node, Predicate<Node> isAcceptedParentNode)	Traverses the parent chain starting at node and returns the first Node that returns make isAcceptedParentNode evaluate to true.

Uses of Node in com.github.javaparser.resolution.declarations

Methods in com.github.javaparser.resolution.declarations with type parameters of type Node

Modifier and Type	Method	Description
default <N extends Node> Optional<N>	AssociableToAST.toAst(Class<N> clazz)	If the declaration is associated to an AST node and the type matches the expected Class return it, otherwise it returns empty.

Methods in com.github.javaparser.resolution.declarations that return types with arguments of type Node

Modifier and Type	Method	Description
default Optional<Node>	AssociableToAST.toAst()	If the declaration is associated to an AST node return it, otherwise it return empty.

Uses of Node in com.github.javaparser.symbolsolver

Methods in com.github.javaparser.symbolsolver that return types with arguments of type Node

Modifier and Type	Method	Description
private List<Node>	SourceFileInfoExtractor.collectAllNodes(Node node)

Methods in com.github.javaparser.symbolsolver with parameters of type Node

Modifier and Type	Method	Description
private List<Node>	SourceFileInfoExtractor.collectAllNodes(Node node)
private int	SourceFileInfoExtractor.lineNr(Node node)
<T> T	JavaSymbolSolver.resolveDeclaration(Node node, Class<T> resultClass)
private void	SourceFileInfoExtractor.solve(Node node)
private void	SourceFileInfoExtractor.solveMethodCalls(Node node)
ResolvedReferenceTypeDeclaration	JavaSymbolSolver.toTypeDeclaration(Node node)

Uses of Node in com.github.javaparser.symbolsolver.javaparsermodel

Methods in com.github.javaparser.symbolsolver.javaparsermodel that return Node

Modifier and Type	Method	Description
protected Node	JavaParserFacade.findContainingTypeDeclOrObjectCreationExpr(Node node)	Where a node has an interface/class/enum declaration -- or an object creation expression (anonymous inner class) -- as its ancestor, return the nearest one.
protected Node	JavaParserFacade.findContainingTypeDeclOrObjectCreationExpr(Node node, String className)	Where a node has an interface/class/enum declaration -- or an object creation expression in an inner class references an outer class -- as its ancestor, return the declaration corresponding to the class name specified.

Methods in com.github.javaparser.symbolsolver.javaparsermodel with parameters of type Node

Modifier and Type	Method	Description
ResolvedType	JavaParserFacade.convert(Type type, Node node)
Boolean	NormalCompletionVisitor.defaultAction(Node n, Void unused)
PatternVariableResult	PatternVariableVisitor.defaultAction(Node node, Void unused)
protected TypeDeclaration<?>	JavaParserFacade.findContainingTypeDecl(Node node)	Where a node has an interface/class/enum declaration as its ancestor, return the nearest one.
protected Node	JavaParserFacade.findContainingTypeDeclOrObjectCreationExpr(Node node)	Where a node has an interface/class/enum declaration -- or an object creation expression (anonymous inner class) -- as its ancestor, return the nearest one.
protected Node	JavaParserFacade.findContainingTypeDeclOrObjectCreationExpr(Node node, String className)	Where a node has an interface/class/enum declaration -- or an object creation expression in an inner class references an outer class -- as its ancestor, return the declaration corresponding to the class name specified.
protected ResolvedType	JavaParserFacade.getBinaryTypeConcrete(Node left, Node right, boolean solveLambdas, BinaryExpr.Operator operator)
static Context	JavaParserFactory.getContext(Node node, TypeSolver typeSolver)
static SymbolDeclarator	JavaParserFactory.getSymbolDeclarator(Node node, TypeSolver typeSolver)
ResolvedType	JavaParserFacade.getType(Node node)	Get the type associated with the node.
ResolvedType	JavaParserFacade.getType(Node node, boolean solveLambdas)
private ResolvedType	JavaParserFacade.getTypeConcrete(Node node, boolean solveLambdas)	Should return more like a TypeApplication: a TypeDeclaration and possible typeParametersValues or array modifiers.
ResolvedReferenceTypeDeclaration	JavaParserFacade.getTypeDeclaration(Node node)
ResolvedType	JavaParserFacade.getTypeOfThisIn(Node node)	"this" inserted in the given point, which type would have?
private void	JavaParserFacade.solveArguments(Node node, NodeList<Expression> args, boolean solveLambdas, List<ResolvedType> argumentTypes, List<LambdaArgumentTypePlaceholder> placeholders)

Uses of Node in com.github.javaparser.symbolsolver.javaparsermodel.contexts

Classes in com.github.javaparser.symbolsolver.javaparsermodel.contexts with type parameters of type Node

Modifier and Type	Class	Description
class	AbstractJavaParserContext<N extends Node>
class	AbstractMethodLikeDeclarationContext<T extends Node & NodeWithParameters<T> & NodeWithTypeParameters<T>>

Fields in com.github.javaparser.symbolsolver.javaparsermodel.contexts declared as Node

Modifier and Type	Field	Description
protected N	AbstractJavaParserContext.wrappedNode

Methods in com.github.javaparser.symbolsolver.javaparsermodel.contexts that return Node

Modifier and Type	Method	Description
protected Node	AbstractJavaParserContext.getScope(Node node)

Methods in com.github.javaparser.symbolsolver.javaparsermodel.contexts with parameters of type Node

Modifier and Type	Method	Description
List<ResolvedFieldDeclaration>	ClassOrInterfaceDeclarationContext.fieldsExposedToChild(Node child)
List<ResolvedFieldDeclaration>	CompilationUnitContext.fieldsExposedToChild(Node child)
List<ResolvedFieldDeclaration>	RecordDeclarationContext.fieldsExposedToChild(Node child)
SymbolReference<? extends ResolvedValueDeclaration>	AbstractJavaParserContext.findExposedPatternInParentContext(Node parent, String name)
protected Node	AbstractJavaParserContext.getScope(Node node)
List<VariableDeclarator>	BlockStmtContext.localVariablesExposedToChild(Node child)
List<VariableDeclarator>	CatchClauseContext.localVariablesExposedToChild(Node child)
List<VariableDeclarator>	ForEachStatementContext.localVariablesExposedToChild(Node child)
List<VariableDeclarator>	ForStatementContext.localVariablesExposedToChild(Node child)
List<VariableDeclarator>	TryWithResourceContext.localVariablesExposedToChild(Node child)
List<VariableDeclarator>	VariableDeclarationExprContext.localVariablesExposedToChild(Node child)
List<VariableDeclarator>	VariableDeclaratorContext.localVariablesExposedToChild(Node child)
List<Parameter>	CatchClauseContext.parametersExposedToChild(Node child)
List<Parameter>	ConstructorContext.parametersExposedToChild(Node child)
List<Parameter>	LambdaExprContext.parametersExposedToChild(Node child)
List<Parameter>	MethodContext.parametersExposedToChild(Node child)
List<TypePatternExpr>	BinaryExprContext.typePatternExprsExposedToChild(Node child)
List<TypePatternExpr>	BlockStmtContext.typePatternExprsExposedToChild(Node child)	The following rule applies to a block statement S contained in a block that is not a switch block: - A pattern variable introduced by S is definitely matched at all the block statements following S, if any, in the block.
List<TypePatternExpr>	ConditionalExprContext.typePatternExprsExposedToChild(Node child)	The following rules apply to a conditional expression a ? b : c: - A pattern variable introduced by a when true is definitely matched at b.
List<TypePatternExpr>	ForStatementContext.typePatternExprsExposedToChild(Node child)	The following rules apply to a basic for statement: - A pattern variable introduced by the condition expression when true is definitely matched at both the incrementation part and the contained statement.
List<TypePatternExpr>	IfStatementContext.typePatternExprsExposedToChild(Node child)	The following rules apply to a statement if (e) S: - A pattern variable introduced by e when true is definitely matched at S.
List<TypePatternExpr>	SwitchEntryContext.typePatternExprsExposedToChild(Node child)
List<TypePatternExpr>	WhileStatementContext.typePatternExprsExposedToChild(Node child)	The following rules apply to a statement while (e) S: - A pattern variable introduced by e when true is definitely matched at S.
private List<TypePatternExpr>	BinaryExprContext.typePatternExprsExposedToChildByAnd(Node child)	The following rules apply to a conditional-and expression a invalid input: '&'invalid input: '&' b: - A pattern variable introduced by a when true is definitely matched at b.
private List<TypePatternExpr>	BinaryExprContext.typePatternExprsExposedToChildByOr(Node child)	The following rules apply to a conditional-and expression a || b: - A pattern variable introduced by a when false is definitely matched at b.

Uses of Node in com.github.javaparser.symbolsolver.javaparsermodel.declarations

Classes in com.github.javaparser.symbolsolver.javaparsermodel.declarations with type parameters of type Node

Modifier and Type	Class	Description
class	JavaParserTypeAdapter<T extends Node & NodeWithSimpleName<T> & NodeWithMembers<T> & NodeWithAnnotations<T>>

Fields in com.github.javaparser.symbolsolver.javaparsermodel.declarations declared as Node

Modifier and Type	Field	Description
private T	JavaParserTypeAdapter.wrappedNode

Methods in com.github.javaparser.symbolsolver.javaparsermodel.declarations with type parameters of type Node

Modifier and Type	Method	Description
<T extends Node> List<T>	JavaParserAnonymousClassDeclaration.findMembersOfKind(Class<T> memberClass)

Methods in com.github.javaparser.symbolsolver.javaparsermodel.declarations that return types with arguments of type Node

Modifier and Type	Method	Description
Optional<Node>	JavaParserAnnotationDeclaration.toAst()
Optional<Node>	JavaParserAnnotationMemberDeclaration.toAst()
Optional<Node>	JavaParserAnonymousClassDeclaration.toAst()
Optional<Node>	JavaParserClassDeclaration.toAst()
Optional<Node>	JavaParserConstructorDeclaration.toAst()
Optional<Node>	JavaParserEnumConstantDeclaration.toAst()
Optional<Node>	JavaParserEnumDeclaration.toAst()
Optional<Node>	JavaParserEnumDeclaration.ValueOfMethod.toAst()
Optional<Node>	JavaParserEnumDeclaration.ValuesMethod.toAst()
Optional<Node>	JavaParserFieldDeclaration.toAst()
Optional<Node>	JavaParserInterfaceDeclaration.toAst()
Optional<Node>	JavaParserMethodDeclaration.toAst()
Optional<Node>	JavaParserParameterDeclaration.toAst()
Optional<Node>	JavaParserRecordDeclaration.ImplicitGetterMethod.toAst()
Optional<Node>	JavaParserRecordDeclaration.toAst()
Optional<Node>	JavaParserTypeParameter.toAst()
Optional<Node>	JavaParserTypePatternDeclaration.toAst()
Optional<Node>	JavaParserTypeVariableDeclaration.toAst()
Optional<Node>	JavaParserVariableDeclaration.toAst()

Methods in com.github.javaparser.symbolsolver.javaparsermodel.declarations with parameters of type Node

Modifier and Type	Method	Description
(package private) static String	AstResolutionUtils.containerName(Node container)
(package private) static String	AstResolutionUtils.getClassName(String base, Node container)
(package private) static String	AstResolutionUtils.getPackageName(Node container)
ResolvedType	JavaParserClassDeclaration.getUsage(Node node)
MethodUsage	JavaParserEnumDeclaration.ValueOfMethod.getUsage(Node node)
MethodUsage	JavaParserEnumDeclaration.ValuesMethod.getUsage(Node node)
ResolvedType	JavaParserInterfaceDeclaration.getUsage(Node node)
MethodUsage	JavaParserMethodDeclaration.getUsage(Node node)
ResolvedType	JavaParserRecordDeclaration.getUsage(Node node)
ResolvedType	JavaParserTypeParameter.getUsage(Node node)
ResolvedType	JavaParserTypeVariableDeclaration.getUsage(Node node)

Uses of Node in com.github.javaparser.symbolsolver.javaparsermodel.declarators

Classes in com.github.javaparser.symbolsolver.javaparsermodel.declarators with type parameters of type Node

Modifier and Type	Class	Description
class	AbstractSymbolDeclarator<N extends Node>
class	NoSymbolDeclarator<N extends Node>

Fields in com.github.javaparser.symbolsolver.javaparsermodel.declarators declared as Node

Modifier and Type	Field	Description
protected N	AbstractSymbolDeclarator.wrappedNode

Uses of Node in com.github.javaparser.symbolsolver.javassistmodel

Methods in com.github.javaparser.symbolsolver.javassistmodel with parameters of type Node

Modifier and Type	Method	Description
ResolvedType	JavassistClassDeclaration.getUsage(Node node)
MethodUsage	JavassistMethodDeclaration.getUsage(Node node)
ResolvedType	JavassistRecordDeclaration.getUsage(Node node)

Uses of Node in com.github.javaparser.symbolsolver.reflectionmodel

Methods in com.github.javaparser.symbolsolver.reflectionmodel that return types with arguments of type Node

Modifier and Type	Method	Description
Optional<Node>	ReflectionRecordDeclaration.toAst()

Methods in com.github.javaparser.symbolsolver.reflectionmodel with parameters of type Node

Modifier and Type	Method	Description
ResolvedType	ReflectionClassDeclaration.getUsage(Node node)
ResolvedType	ReflectionInterfaceDeclaration.getUsage(Node node)
ResolvedType	ReflectionRecordDeclaration.getUsage(Node node)

Uses of Node in com.github.javaparser.symbolsolver.resolution

Methods in com.github.javaparser.symbolsolver.resolution with parameters of type Node

Modifier and Type	Method	Description
MethodUsage	SymbolSolver.solveMethod(String methodName, List<ResolvedType> argumentsTypes, Node node)
SymbolReference<? extends ResolvedValueDeclaration>	SymbolSolver.solveSymbol(String name, Node node)
Optional<Value>	SymbolSolver.solveSymbolAsValue(String name, Node node)
SymbolReference<? extends ResolvedTypeDeclaration>	SymbolSolver.solveType(String name, Node node)

Uses of Node in com.github.javaparser.symbolsolver.resolution.naming

Classes in com.github.javaparser.symbolsolver.resolution.naming with type parameters of type Node

Modifier and Type	Interface	Description
private static interface	NameLogic.PredicateOnParentAndChild<P extends Node, C extends Node>
private static interface	NameLogic.PredicateOnParentAndChild<P extends Node, C extends Node>

Methods in com.github.javaparser.symbolsolver.resolution.naming with type parameters of type Node

Modifier and Type	Method	Description
private static <P extends Node, C extends Node> boolean	NameLogic.whenParentIs(Class<P> parentClass, C child)
private static <P extends Node, C extends Node> boolean	NameLogic.whenParentIs(Class<P> parentClass, C child)
private static <P extends Node, C extends Node> boolean	NameLogic.whenParentIs(Class<P> parentClass, C child, NameLogic.PredicateOnParentAndChild<P,C> predicate)
private static <P extends Node, C extends Node> boolean	NameLogic.whenParentIs(Class<P> parentClass, C child, NameLogic.PredicateOnParentAndChild<P,C> predicate)

Methods in com.github.javaparser.symbolsolver.resolution.naming that return Node

Modifier and Type	Method	Description
private static Node	NameLogic.getQualifier(Node node)
private static Node	NameLogic.getRightMostName(Node node)

Methods in com.github.javaparser.symbolsolver.resolution.naming with parameters of type Node

Modifier and Type	Method	Description
static NameCategory	NameLogic.classifyReference(Node name, TypeSolver typeSolver)
static NameRole	NameLogic.classifyRole(Node name)	What is the Role of the given name? Does it represent a Declaration or a Reference?
private static Node	NameLogic.getQualifier(Node node)
private static Node	NameLogic.getRightMostName(Node node)
static boolean	NameLogic.isAName(Node node)	Does the Node represent a Name?
static boolean	NameLogic.isQualifiedName(Node node)	Is the given node a qualified name?
static boolean	NameLogic.isSimpleName(Node node)	Is the given node a non-qualified name?
private static boolean	NameLogic.isSyntacticallyAAmbiguousName(Node name)
private static boolean	NameLogic.isSyntacticallyAMethodName(Node name)
private static boolean	NameLogic.isSyntacticallyAModuleName(Node name)
private static boolean	NameLogic.isSyntacticallyAnExpressionName(Node name)
private static boolean	NameLogic.isSyntacticallyAPackageName(Node name)
private static boolean	NameLogic.isSyntacticallyAPackageOrTypeName(Node name)
private static boolean	NameLogic.isSyntacticallyATypeName(Node name)
static String	NameLogic.nameAsString(Node name)	Return the string representation of the name
private static NameCategory	NameLogic.reclassificationOfContextuallyAmbiguousNames(Node name, NameCategory ambiguousCategory, TypeSolver typeSolver)	JLS 6.5.2.
private static NameCategory	NameLogic.reclassificationOfContextuallyAmbiguousPackageOrTypeName(Node name, TypeSolver typeSolver)
private static NameCategory	NameLogic.reclassificationOfContextuallyAmbiguousQualifiedAmbiguousName(Node nameNode, TypeSolver typeSolver)
private static NameCategory	NameLogic.reclassificationOfContextuallyAmbiguousSimpleAmbiguousName(Node nameNode, TypeSolver typeSolver)
static NameCategory	NameLogic.syntacticClassificationAccordingToContext(Node name)	See JLS 6.5.1 Syntactic Classification of a Name According to Context.

Uses of Node in com.github.javaparser.symbolsolver.resolution.typeinference

Methods in com.github.javaparser.symbolsolver.resolution.typeinference with type parameters of type Node

Modifier and Type	Method	Description
private <P extends Node> boolean	ControlFlowLogic.parentIs(Node node, Class<P> parentClass)

Methods in com.github.javaparser.symbolsolver.resolution.typeinference with parameters of type Node

Modifier and Type	Method	Description
private <P extends Node> boolean	ControlFlowLogic.parentIs(Node node, Class<P> parentClass)

Uses of Node in com.github.javaparser.utils

Classes in com.github.javaparser.utils with type parameters of type Node

Modifier and Type	Class	Description
class	VisitorList<N extends Node>	A list that overrides the equals and hashcode calculation of the added nodes by using another equals and hashcode visitor for those methods.
class	VisitorMap<N extends Node, V>	A map that overrides the equals and hashcode calculation of the added nodes by using another equals and hashcode visitor for those methods.
class	VisitorSet<N extends Node>	A set that overrides the equals and hashcode calculation of the added nodes by using another equals and hashcode visitor for those methods.

Fields in com.github.javaparser.utils declared as Node

Modifier and Type	Field	Description
private final N	VisitorList.EqualsHashcodeOverridingFacade.overridden
private final N	VisitorMap.EqualsHashcodeOverridingFacade.overridden
private final N	VisitorSet.EqualsHashcodeOverridingFacade.overridden

Methods in com.github.javaparser.utils with type parameters of type Node

Modifier and Type	Method	Description
static <T extends Node> void	PositionUtils.sortByBeginPosition(NodeList<T> nodes)
static <T extends Node> void	PositionUtils.sortByBeginPosition(List<T> nodes)
static <T extends Node> void	PositionUtils.sortByBeginPosition(List<T> nodes, boolean ignoringAnnotations)

Methods in com.github.javaparser.utils that return Node

Modifier and Type	Method	Description
private static Node	PositionUtils.firstNonAnnotationNode(Node node)

Methods in com.github.javaparser.utils with parameters of type Node

Modifier and Type	Method	Description
static boolean	PositionUtils.areInOrder(Node a, Node b)
static boolean	PositionUtils.areInOrder(Node a, Node b, boolean ignoringAnnotations)
private static int	PositionUtils.beginColumnWithoutConsideringAnnotation(Node node)
private static int	PositionUtils.beginLineWithoutConsideringAnnotation(Node node)
private static int	PositionUtils.compare(Node a, Node b, boolean ignoringAnnotations)
private static Node	PositionUtils.firstNonAnnotationNode(Node node)
static AnnotationExpr	PositionUtils.getLastAnnotation(Node node)
static boolean	Utils.hasUnaryMinusAsParent(Node n)	Checks, if the parent is a unary expression with a minus operator.
static boolean	PositionUtils.nodeContains(Node container, Node other, boolean ignoringAnnotations)	Compare the position of two nodes.