diff options
| author | Danny van Bruggen <lol@meuk.info> | 2016-10-16 21:56:09 +0200 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2016-10-16 21:56:09 +0200 |
| commit | 515a9392928c14a60dc9dfa42a98198a4d877534 (patch) | |
| tree | 766d85c38eea6f560b55ebfee1d816ae7bdd6cec /javaparser-core/src/main/java/com/github | |
| parent | cb168d96d0518a9ebd23ce00c668ccf70045c508 (diff) | |
| download | platform_external_javaparser-515a9392928c14a60dc9dfa42a98198a4d877534.tar.gz platform_external_javaparser-515a9392928c14a60dc9dfa42a98198a4d877534.tar.bz2 platform_external_javaparser-515a9392928c14a60dc9dfa42a98198a4d877534.zip | |
Issue 421 parenting of collections (#501)
* Migrate from List to NodeList
* Disallow usage of null in the AST
* Use Optional where fields are optional (previously nullable)
Diffstat (limited to 'javaparser-core/src/main/java/com/github')
121 files changed, 2799 insertions, 2758 deletions
diff --git a/javaparser-core/src/main/java/com/github/javaparser/CommentsInserter.java b/javaparser-core/src/main/java/com/github/javaparser/CommentsInserter.java index eee450d20..8cccd5678 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/CommentsInserter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/CommentsInserter.java @@ -30,6 +30,7 @@ import com.github.javaparser.utils.PositionUtils; import java.util.*; import static com.github.javaparser.ast.Node.NODE_BY_BEGIN_POSITION; +import static com.github.javaparser.utils.Utils.some; /** * Assigns comments to nodes of the AST. @@ -60,14 +61,13 @@ class CommentsInserter { // so I could use some heuristics in these cases to distinguish the two // cases - List<Node> children = cu.getChildrenNodes(); - PositionUtils.sortByBeginPosition(children); + List<Node> children = cu.getBackwardsCompatibleChildrenNodes(); Comment firstComment = comments.iterator().next(); - if (cu.getPackage() != null + if (cu.getPackage().isPresent() && (children.isEmpty() || PositionUtils.areInOrder( - firstComment, children.get(0)))) { - cu.setComment(firstComment); + firstComment, cu.getPackage().get()))) { + cu.setComment(some(firstComment)); comments.remove(firstComment); } } @@ -92,8 +92,7 @@ class CommentsInserter { // if they preceed a child they are assigned to it, otherweise they // remain "orphans" - List<Node> children = node.getChildrenNodes(); - PositionUtils.sortByBeginPosition(children); + List<Node> children = node.getBackwardsCompatibleChildrenNodes(); for (Node child : children) { TreeSet<Comment> commentsInsideChild = new TreeSet<>(NODE_BY_BEGIN_POSITION); @@ -121,13 +120,17 @@ class CommentsInserter { } } } + commentsToAttribute.removeAll(attributedComments); /* at this point I create an ordered list of all remaining comments and children */ Comment previousComment = null; attributedComments = new LinkedList<>(); List<Node> childrenAndComments = new LinkedList<>(); - childrenAndComments.addAll(children); + for (Node child : children) { + // Avoid attributing comments to a meaningless container. + childrenAndComments.add(child); + } childrenAndComments.addAll(commentsToAttribute); PositionUtils.sortByBeginPosition(childrenAndComments, configuration.doNotConsiderAnnotationsAsNodeStartForCodeAttribution); @@ -139,10 +142,10 @@ class CommentsInserter { previousComment = null; } } else { - if (previousComment != null && !thing.hasComment()) { + if (previousComment != null && !thing.getComment().isPresent()) { if (!configuration.doNotAssignCommentsPrecedingEmptyLines || !thereAreLinesBetween(previousComment, thing)) { - thing.setComment(previousComment); + thing.setComment(some(previousComment)); attributedComments.add(previousComment); previousComment = null; } @@ -164,9 +167,9 @@ class CommentsInserter { // The node start and end at the same line as the comment, // let's give to it the comment if (node.getBegin().line == lineComment.getBegin().line - && !node.hasComment()) { + && !node.getComment().isPresent()) { if(!(node instanceof Comment)) { - node.setComment(lineComment); + node.setComment(some(lineComment)); } return true; } else { diff --git a/javaparser-core/src/main/java/com/github/javaparser/JavaParser.java b/javaparser-core/src/main/java/com/github/javaparser/JavaParser.java index 0c14c2b17..66fc51896 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/JavaParser.java +++ b/javaparser-core/src/main/java/com/github/javaparser/JavaParser.java @@ -39,6 +39,7 @@ import java.util.Optional; import static com.github.javaparser.ParseStart.*; import static com.github.javaparser.Providers.UTF8; import static com.github.javaparser.Providers.provider; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * Parse Java source code and creates Abstract Syntax Trees. @@ -86,6 +87,8 @@ public final class JavaParser { * @return the parse result, a collection of encountered problems, and some extra data. */ public <N extends Node> ParseResult<N> parse(ParseStart<N> start, Provider provider) { + assertNotNull(start); + assertNotNull(provider); try { final ASTParser parser = getParserForProvider(provider); N resultNode = start.parse(parser); @@ -262,8 +265,8 @@ public final class JavaParser { * @return Expression representing the Java expression * @throws ParseProblemException if the source code has parser errors */ - public static Expression parseExpression(final String expression) { - return simplifiedParse(EXPRESSION, provider(expression)); + public static <T extends Expression> T parseExpression(final String expression) { + return (T) simplifiedParse(EXPRESSION, provider(expression)); } /** diff --git a/javaparser-core/src/main/java/com/github/javaparser/ParseResult.java b/javaparser-core/src/main/java/com/github/javaparser/ParseResult.java index 88e400525..6a375906e 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ParseResult.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ParseResult.java @@ -36,7 +36,16 @@ public class ParseResult<T> { * Used when parsing failed completely with an exception. */ ParseResult(Throwable throwable) { - this(Optional.empty(), singletonList(new Problem(throwable.getMessage(), Optional.empty(), Optional.of(throwable))), Optional.empty(), Optional.empty()); + this(Optional.empty(), singletonList( + new Problem(createMessage(throwable), Optional.empty(), Optional.of(throwable))), Optional.empty(), Optional.empty()); + } + + private static String createMessage(Throwable throwable) { + String message = throwable.getMessage(); + if (message == null) { + return throwable.getClass().getSimpleName(); + } + return message; } /** diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayBracketPair.java b/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayBracketPair.java index cca0b8761..507352ac4 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayBracketPair.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayBracketPair.java @@ -2,23 +2,20 @@ package com.github.javaparser.ast; import com.github.javaparser.Range; import com.github.javaparser.ast.expr.AnnotationExpr; -import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * In, for example, <code>int[] a[];</code> there are two ArrayBracketPair objects, * one for the [] after int, one for the [] after a. */ public class ArrayBracketPair extends Node implements NodeWithAnnotations<ArrayBracketPair> { - private List<AnnotationExpr> annotations; + private NodeList<AnnotationExpr> annotations = new NodeList<>(); - public ArrayBracketPair(Range range, List<AnnotationExpr> annotations) { + public ArrayBracketPair(Range range, NodeList<AnnotationExpr> annotations) { super(range); setAnnotations(annotations); } @@ -31,14 +28,13 @@ public class ArrayBracketPair extends Node implements NodeWithAnnotations<ArrayB v.visit(this, arg); } - public List<AnnotationExpr> getAnnotations() { - annotations = ensureNotNull(annotations); + public NodeList<AnnotationExpr> getAnnotations() { return annotations; } - public ArrayBracketPair setAnnotations(List<AnnotationExpr> annotations) { + public ArrayBracketPair setAnnotations(NodeList<AnnotationExpr> annotations) { setAsParentNodeOf(annotations); - this.annotations = annotations; + this.annotations = assertNotNull(annotations); return this; } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayCreationLevel.java b/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayCreationLevel.java index 2edc68c2a..4f35e9924 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayCreationLevel.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/ArrayCreationLevel.java @@ -7,9 +7,9 @@ import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * In <code>new int[1][2];</code> there are two ArrayCreationLevel objects, @@ -17,10 +17,10 @@ import static com.github.javaparser.utils.Utils.ensureNotNull; * the second the expression "2". */ public class ArrayCreationLevel extends Node implements NodeWithAnnotations<ArrayCreationLevel> { - private Expression dimension; - private List<AnnotationExpr> annotations; + private Optional<Expression> dimension; + private NodeList<AnnotationExpr> annotations = new NodeList<>(); - public ArrayCreationLevel(Range range, Expression dimension, List<AnnotationExpr> annotations) { + public ArrayCreationLevel(Range range, Optional<Expression> dimension, NodeList<AnnotationExpr> annotations) { super(range); setDimension(dimension); setAnnotations(annotations); @@ -34,23 +34,23 @@ public class ArrayCreationLevel extends Node implements NodeWithAnnotations<Arra v.visit(this, arg); } - public void setDimension(Expression dimension) { - this.dimension = dimension; + public ArrayCreationLevel setDimension(Optional<Expression> dimension) { + this.dimension = assertNotNull(dimension); setAsParentNodeOf(dimension); + return this; } - public Expression getDimension() { + public Optional<Expression> getDimension() { return dimension; } - public List<AnnotationExpr> getAnnotations() { - annotations = ensureNotNull(annotations); + public NodeList<AnnotationExpr> getAnnotations() { return annotations; } - public ArrayCreationLevel setAnnotations(List<AnnotationExpr> annotations) { + public ArrayCreationLevel setAnnotations(NodeList<AnnotationExpr> annotations) { setAsParentNodeOf(annotations); - this.annotations = annotations; + this.annotations = assertNotNull(annotations); return this; } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/CompilationUnit.java b/javaparser-core/src/main/java/com/github/javaparser/ast/CompilationUnit.java index eac3a3696..bd1fa0921 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/CompilationUnit.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/CompilationUnit.java @@ -26,7 +26,6 @@ import com.github.javaparser.ast.body.*; import com.github.javaparser.ast.comments.Comment; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.imports.*; -import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import com.github.javaparser.utils.ClassUtils; @@ -34,10 +33,13 @@ import com.github.javaparser.utils.ClassUtils; import java.util.Arrays; import java.util.EnumSet; import java.util.List; +import java.util.Optional; import java.util.stream.Collectors; import static com.github.javaparser.ast.expr.NameExpr.name; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; /** * <p> @@ -58,23 +60,22 @@ import static com.github.javaparser.utils.Utils.ensureNotNull; */ public final class CompilationUnit extends Node { - private PackageDeclaration pakage; + private Optional<PackageDeclaration> pakage; - private List<ImportDeclaration> imports; + private NodeList<ImportDeclaration> imports; - private List<TypeDeclaration<?>> types; + private NodeList<TypeDeclaration<?>> types; public CompilationUnit() { + this(Range.UNKNOWN, none(), new NodeList<>(), new NodeList<>()); } - public CompilationUnit(PackageDeclaration pakage, List<ImportDeclaration> imports, List<TypeDeclaration<?>> types) { - setPackage(pakage); - setImports(imports); - setTypes(types); + public CompilationUnit(Optional<PackageDeclaration> pakage, NodeList<ImportDeclaration> imports, NodeList<TypeDeclaration<?>> types) { + this(Range.UNKNOWN, pakage, imports, types); } - public CompilationUnit(Range range, PackageDeclaration pakage, List<ImportDeclaration> imports, - List<TypeDeclaration<?>> types) { + public CompilationUnit(Range range, Optional<PackageDeclaration> pakage, NodeList<ImportDeclaration> imports, + NodeList<TypeDeclaration<?>> types) { super(range); setPackage(pakage); setImports(imports); @@ -113,8 +114,7 @@ public final class CompilationUnit extends Node { * * @return the list of imports or <code>null</code> if there is no import */ - public List<ImportDeclaration> getImports() { - imports = ensureNotNull(imports); + public NodeList<ImportDeclaration> getImports() { return imports; } @@ -125,7 +125,7 @@ public final class CompilationUnit extends Node { * * @return the package declaration or <code>null</code> */ - public PackageDeclaration getPackage() { + public Optional<PackageDeclaration> getPackage() { return pakage; } @@ -139,30 +139,19 @@ public final class CompilationUnit extends Node { * @see EmptyTypeDeclaration * @see EnumDeclaration */ - public List<TypeDeclaration<?>> getTypes() { - types = ensureNotNull(types); + public NodeList<TypeDeclaration<?>> getTypes() { return types; } /** - * Sets the list of comments of this compilation unit. - * - * @param comments - * the list of comments - */ - public CompilationUnit setComments(List<Comment> comments) { - throw new RuntimeException("Not implemented!"); - } - - /** * Sets the list of imports of this compilation unit. The list is initially * <code>null</code>. * * @param imports * the list of imports */ - public CompilationUnit setImports(List<ImportDeclaration> imports) { - this.imports = imports; + public CompilationUnit setImports(NodeList<ImportDeclaration> imports) { + this.imports = assertNotNull(imports); setAsParentNodeOf(this.imports); return this; } @@ -174,7 +163,7 @@ public final class CompilationUnit extends Node { * the pakage declaration to set or <code>null</code> to default * package */ - public CompilationUnit setPackage(PackageDeclaration pakage) { + public CompilationUnit setPackage(Optional<PackageDeclaration> pakage) { this.pakage = pakage; setAsParentNodeOf(this.pakage); return this; @@ -186,8 +175,8 @@ public final class CompilationUnit extends Node { * @param types * the lis of types */ - public CompilationUnit setTypes(List<TypeDeclaration<?>> types) { - this.types = types; + public CompilationUnit setTypes(NodeList<TypeDeclaration<?>> types) { + this.types = assertNotNull(types); setAsParentNodeOf(this.types); return this; } @@ -199,7 +188,7 @@ public final class CompilationUnit extends Node { * @return this, the {@link CompilationUnit} */ public CompilationUnit setPackageName(String name) { - setPackage(new PackageDeclaration(name(name))); + setPackage(some(new PackageDeclaration(name(name)))); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/Node.java b/javaparser-core/src/main/java/com/github/javaparser/ast/Node.java index 8e5f3acaf..4e3c3efc4 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/Node.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/Node.java @@ -35,9 +35,15 @@ import com.github.javaparser.ast.comments.BlockComment; import com.github.javaparser.ast.comments.Comment; import com.github.javaparser.ast.comments.LineComment; import com.github.javaparser.ast.visitor.*; +import com.github.javaparser.utils.PositionUtils; import java.util.*; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; +import static java.util.Collections.*; + /** * Abstract class for all nodes of the AST. * @@ -62,11 +68,7 @@ public abstract class Node implements Cloneable { private IdentityHashMap<UserDataKey<?>, Object> userData = null; - private Comment comment; - - public Node() { - this(Range.UNKNOWN); - } + private Optional<? extends Comment> comment = none(); public Node(Range range) { this.range = range; @@ -104,7 +106,7 @@ public abstract class Node implements Cloneable { * * @return comment property */ - public final Comment getComment() { + public Optional<? extends Comment> getComment() { return comment; } @@ -158,17 +160,12 @@ public abstract class Node implements Cloneable { * * @param comment to be set */ - public final Node setComment(final Comment comment) { - if (comment != null && (this instanceof Comment)) { - throw new RuntimeException("A comment can not be commented"); - } - if (this.comment != null) { - this.comment.setCommentedNode(null); - } + public final Node setComment(final Optional<? extends Comment> comment) { + assertNotNull(comment); + comment.ifPresent(c -> {if (this instanceof Comment) throw new AssertionError("A comment can not be commented");}); + this.comment.ifPresent(c -> c.setCommentedNode(null)); this.comment = comment; - if (comment != null) { - this.comment.setCommentedNode(this); - } + this.comment.ifPresent(c -> c.setCommentedNode(this)); return this; } @@ -178,7 +175,7 @@ public abstract class Node implements Cloneable { * @param comment to be set */ public final Node setLineComment(String comment) { - return setComment(new LineComment(comment)); + return setComment(some(new LineComment(comment))); } /** @@ -187,7 +184,7 @@ public abstract class Node implements Cloneable { * @param comment to be set */ public final Node setBlockComment(String comment) { - return setComment(new BlockComment(comment)); + return setComment(some(new BlockComment(comment))); } /** @@ -241,12 +238,43 @@ public abstract class Node implements Cloneable { return null; } + /** + * Contains all nodes that have this node set as their parent. + * You can add nodes to it by setting a node's parent to this node. + * You can remove nodes from it by setting a child node's parent to something other than this node. + * + * @return all nodes that have this node as their parent. + */ public List<Node> getChildrenNodes() { - return childrenNodes; + return unmodifiableList(childrenNodes); + } + + /** + * Before 3.0.0.alpha-5, if we had a list of nodes, those nodes would not have the list + * as its parent, but the node containing the list. + * This method returns the children in that way: there are no lists, and all nodes that are + * in lists are directly in this list. + * @deprecated this will be gone in 3.0.0 release. + */ + @Deprecated + public List<Node> getBackwardsCompatibleChildrenNodes() { + List<Node> children = new ArrayList<>(); + for (Node childNode : getChildrenNodes()) { + // Avoid attributing comments to NodeLists by pretending they don't exist. + if (childNode instanceof NodeList) { + for (Node subChildNode : ((NodeList<Node>) childNode)) { + children.add(subChildNode); + } + } else { + children.add(childNode); + } + } + PositionUtils.sortByBeginPosition(children); + return children; } - public boolean contains(Node other) { - return range.contains(other.range); + public <N extends Node> boolean containsWithin(N other) { + return range.contains(other.getRange()); } public void addOrphanComment(Comment comment) { @@ -282,8 +310,8 @@ public abstract class Node implements Cloneable { comments.addAll(getOrphanComments()); for (Node child : getChildrenNodes()) { - if (child.getComment() != null) { - comments.add(child.getComment()); + if (child.getComment().isPresent()) { + comments.add(child.getComment().get()); } comments.addAll(child.getAllContainedComments()); } @@ -323,6 +351,11 @@ public abstract class Node implements Cloneable { } } + protected void setAsParentNodeOf(Optional<? extends Node> childNode) { + assertNotNull(childNode); + childNode.ifPresent(c -> c.setParentNode(this)); + } + public static final int ABSOLUTE_BEGIN_LINE = -1; public static final int ABSOLUTE_END_LINE = -2; @@ -334,10 +367,6 @@ public abstract class Node implements Cloneable { return range.isBefore(position); } - public boolean hasComment() { - return comment != null; - } - public void tryAddImportToParentCompilationUnit(Class<?> clazz) { CompilationUnit parentNode = getParentNodeOfType(CompilationUnit.class); if (parentNode != null) { @@ -407,6 +436,7 @@ public abstract class Node implements Cloneable { * @throws RuntimeException if it fails in an unexpected way */ public boolean remove() { + Node parentNode = this.parentNode; if (parentNode == null) return false; boolean success = false; @@ -422,6 +452,9 @@ public abstract class Node implements Cloneable { Collection<?> l = (Collection<?>) object; boolean remove = l.remove(this); success |= remove; + } else if (NodeList.class.isAssignableFrom(object.getClass())) { + NodeList<Node> l = (NodeList<Node>) object; + success |= l.remove(this); } else if (Optional.class.equals(f.getType())) { Optional<?> opt = (Optional<?>) object; if (opt.isPresent()) diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/NodeList.java b/javaparser-core/src/main/java/com/github/javaparser/ast/NodeList.java new file mode 100644 index 000000000..e49c179f8 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/NodeList.java @@ -0,0 +1,162 @@ +package com.github.javaparser.ast; + +import com.github.javaparser.Position; +import com.github.javaparser.Range; +import com.github.javaparser.ast.visitor.GenericVisitor; +import com.github.javaparser.ast.visitor.VoidVisitor; + +import java.util.*; +import java.util.function.Consumer; +import java.util.stream.Stream; + +/** + * A node that is a list of nodes. + * + * @param <N> the type of nodes contained. + */ +public class NodeList<N extends Node> extends Node implements Iterable<N> { + // TODO we probably want to use the already existing childrenNodes list for this. + private List<N> innerList = new ArrayList<>(0); + + public NodeList() { + this(Range.UNKNOWN, null); + } + + public NodeList(Node parent) { + this(Range.UNKNOWN, parent); + } + + public NodeList(Range range, Node parent) { + super(range); + setParentNode(parent); + } + + public NodeList<N> add(N node) { + own(node); + innerList.add(node); + return this; + } + + private void own(N node) { + if (node == null) { + return; + } + setAsParentNodeOf(node); + // Expand the NodeList's range to include the new node. + if (getRange() == Range.UNKNOWN) { + setRange(node.getRange()); + } else { + Position nodeBegin = node.getBegin(); + if (nodeBegin.valid()) { + if(nodeBegin.isBefore(getBegin())){ + setBegin(nodeBegin); + } + } + Position nodeEnd = node.getEnd(); + if (nodeEnd.valid()) { + if(nodeEnd.isAfter(getEnd())){ + setEnd(nodeEnd); + } + } + } + } + + public boolean remove(Node node) { + boolean remove = innerList.remove(node); + node.setParentNode(null); + return remove; + } + + public static <X extends Node> NodeList<X> nodeList(X... nodes) { + final NodeList<X> nodeList = new NodeList<>(); + for (X node : nodes) { + nodeList.add(node); + } + return nodeList; + } + + public static <X extends Node> NodeList<X> nodeList(Collection<X> nodes) { + final NodeList<X> nodeList = new NodeList<>(); + for (X node : nodes) { + nodeList.add(node); + } + return nodeList; + } + + public static <X extends Node> NodeList<X> nodeList(NodeList<X> nodes) { + final NodeList<X> nodeList = new NodeList<>(); + for (X node : nodes) { + nodeList.add(node); + } + return nodeList; + } + + public boolean contains(N node) { + return innerList.contains(node); + } + + public Stream<N> stream() { + return innerList.stream(); + } + + @Override + public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { + return v.visit(this, arg); + } + + @Override + public <A> void accept(final VoidVisitor<A> v, final A arg) { + v.visit(this, arg); + } + + public int size() { + return innerList.size(); + } + + public N get(int i) { + return innerList.get(i); + } + + @Override + public Iterator<N> iterator() { + // TODO take care of "Iterator.remove" + return innerList.iterator(); + } + + public NodeList<N> set(int index, N element) { + setAsParentNodeOf(element); + innerList.set(index, element); + return this; + } + + public NodeList<N> remove(int index) { + innerList.remove(index); + return this; + } + + public boolean isEmpty() { + return innerList.isEmpty(); + } + + public void ifNotEmpty(Consumer<NodeList<N>> consumer) { + if (!isEmpty()) { + consumer.accept(this); + } + } + + public void sort(Comparator<? super N> comparator) { + Collections.sort(innerList, comparator); + } + + public void addAll(NodeList<N> otherList) { + for (N node : otherList) { + add(node); + } + } + + public NodeList<N> add(int index, N node) { + own(node); + innerList.add(index, node); + return this; + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/PackageDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/PackageDeclaration.java index 4252ad4e9..a207d6cf2 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/PackageDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/PackageDeclaration.java @@ -25,11 +25,10 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; -import com.github.javaparser.utils.Utils; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * <p> @@ -46,23 +45,23 @@ import java.util.List; */ public final class PackageDeclaration extends Node implements NodeWithAnnotations<PackageDeclaration> { - private List<AnnotationExpr> annotations; + private NodeList<AnnotationExpr> annotations = new NodeList<>(); private NameExpr name; public PackageDeclaration() { + this(Range.UNKNOWN, new NodeList<>(), new NameExpr()); } public PackageDeclaration(NameExpr name) { - setName(name); + this(Range.UNKNOWN, new NodeList<>(), name); } - public PackageDeclaration(List<AnnotationExpr> annotations, NameExpr name) { - setAnnotations(annotations); - setName(name); + public PackageDeclaration(NodeList<AnnotationExpr> annotations, NameExpr name) { + this(Range.UNKNOWN, annotations, name); } - public PackageDeclaration(Range range, List<AnnotationExpr> annotations, NameExpr name) { + public PackageDeclaration(Range range, NodeList<AnnotationExpr> annotations, NameExpr name) { super(range); setAnnotations(annotations); setName(name); @@ -84,8 +83,7 @@ public final class PackageDeclaration extends Node implements NodeWithAnnotation * * @return list of annotations or <code>null</code> */ - public List<AnnotationExpr> getAnnotations() { - annotations = Utils.ensureNotNull(annotations); + public NodeList<AnnotationExpr> getAnnotations() { return annotations; } @@ -109,8 +107,8 @@ public final class PackageDeclaration extends Node implements NodeWithAnnotation * @param annotations * the annotations to set */ - public PackageDeclaration setAnnotations(List<AnnotationExpr> annotations) { - this.annotations = annotations; + public PackageDeclaration setAnnotations(NodeList<AnnotationExpr> annotations) { + this.annotations = assertNotNull(annotations); setAsParentNodeOf(this.annotations); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationDeclaration.java index 74d84e822..aeb0aeae9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationDeclaration.java @@ -27,29 +27,47 @@ import java.util.EnumSet; import com.github.javaparser.Range; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; +import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.ast.expr.NameExpr.*; + /** * @author Julio Vilmar Gesser */ public final class AnnotationDeclaration extends TypeDeclaration<AnnotationDeclaration> { public AnnotationDeclaration() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new NameExpr(), + new NodeList<>()); } public AnnotationDeclaration(EnumSet<Modifier> modifiers, String name) { - super(modifiers, name); + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + name(name), + new NodeList<>()); } - public AnnotationDeclaration(EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, String name, - List<BodyDeclaration<?>> members) { - super(annotations, modifiers, name, members); + public AnnotationDeclaration(EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, NameExpr name, + NodeList<BodyDeclaration<?>> members) { + this(Range.UNKNOWN, + modifiers, + annotations, + name, + members); } - public AnnotationDeclaration(Range range, EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, String name, - List<BodyDeclaration<?>> members) { + public AnnotationDeclaration(Range range, EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, NameExpr name, + NodeList<BodyDeclaration<?>> members) { super(range, annotations, modifiers, name, members); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationMemberDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationMemberDeclaration.java index 66b9dc3a3..bd8c05819 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationMemberDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/AnnotationMemberDeclaration.java @@ -23,6 +23,7 @@ package com.github.javaparser.ast.body; import com.github.javaparser.Range; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.expr.Expression; @@ -30,49 +31,64 @@ import com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc; import com.github.javaparser.ast.nodeTypes.NodeWithModifiers; import com.github.javaparser.ast.nodeTypes.NodeWithName; import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import java.util.EnumSet; -import java.util.List; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser */ -public final class AnnotationMemberDeclaration extends BodyDeclaration<AnnotationMemberDeclaration> - implements NodeWithJavaDoc<AnnotationMemberDeclaration>, NodeWithName<AnnotationMemberDeclaration>, - NodeWithType<AnnotationMemberDeclaration>, NodeWithModifiers<AnnotationMemberDeclaration> { +public final class AnnotationMemberDeclaration extends BodyDeclaration<AnnotationMemberDeclaration> implements + NodeWithJavaDoc<AnnotationMemberDeclaration>, + NodeWithName<AnnotationMemberDeclaration>, + NodeWithType<AnnotationMemberDeclaration, Type<?>>, + NodeWithModifiers<AnnotationMemberDeclaration> { private EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); - private Type type; + private Type<?> type; private String name; - private Expression defaultValue; + private Optional<Expression> defaultValue; public AnnotationMemberDeclaration() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new ClassOrInterfaceType(), + "empty", + none()); } - public AnnotationMemberDeclaration(EnumSet<Modifier> modifiers, Type type, String name, Expression defaultValue) { - setModifiers(modifiers); - setType(type); - setName(name); - setDefaultValue(defaultValue); + public AnnotationMemberDeclaration(EnumSet<Modifier> modifiers, Type<?> type, String name, Optional<Expression> defaultValue) { + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + type, + name, + defaultValue); } - public AnnotationMemberDeclaration(EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, Type type, String name, - Expression defaultValue) { - super(annotations); - setModifiers(modifiers); - setType(type); - setName(name); - setDefaultValue(defaultValue); + public AnnotationMemberDeclaration(EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, Type<?> type, String name, + Optional<Expression> defaultValue) { + this(Range.UNKNOWN, + modifiers, + annotations, + type, + name, + defaultValue); } - public AnnotationMemberDeclaration(Range range, EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, Type type, - String name, Expression defaultValue) { + public AnnotationMemberDeclaration(Range range, EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, Type type, + String name, Optional<Expression> defaultValue) { super(range, annotations); setModifiers(modifiers); setType(type); @@ -90,7 +106,7 @@ public final class AnnotationMemberDeclaration extends BodyDeclaration<Annotatio v.visit(this, arg); } - public Expression getDefaultValue() { + public Optional<Expression> getDefaultValue() { return defaultValue; } @@ -111,40 +127,43 @@ public final class AnnotationMemberDeclaration extends BodyDeclaration<Annotatio } @Override - public Type getType() { + public Type<?> getType() { return type; } - public AnnotationMemberDeclaration setDefaultValue(Expression defaultValue) { - this.defaultValue = defaultValue; + public AnnotationMemberDeclaration setDefaultValue(Optional<Expression> defaultValue) { + this.defaultValue = assertNotNull(defaultValue); setAsParentNodeOf(defaultValue); return this; } @Override public AnnotationMemberDeclaration setModifiers(EnumSet<Modifier> modifiers) { - this.modifiers = modifiers; + this.modifiers = assertNotNull(modifiers); return this; } @Override public AnnotationMemberDeclaration setName(String name) { - this.name = name; + this.name = assertNotNull(name); return this; } @Override - public AnnotationMemberDeclaration setType(Type type) { - this.type = type; + public AnnotationMemberDeclaration setType(Type<?> type) { + this.type = assertNotNull(type); setAsParentNodeOf(type); return this; } @Override - public JavadocComment getJavaDoc() { - if (getComment() instanceof JavadocComment) { - return (JavadocComment) getComment(); + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } } - return null; + return none(); } + } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/BodyDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/BodyDeclaration.java index 9055d96a5..fd9988066 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/BodyDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/BodyDeclaration.java @@ -25,32 +25,36 @@ import java.util.List; import com.github.javaparser.Range; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.utils.Utils; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ public abstract class BodyDeclaration<T> extends Node implements NodeWithAnnotations<T> { - private List<AnnotationExpr> annotations; + private NodeList<AnnotationExpr> annotations = new NodeList<>(); public BodyDeclaration() { + this(Range.UNKNOWN, new NodeList<>()); } - public BodyDeclaration(List<AnnotationExpr> annotations) { - setAnnotations(annotations); + public BodyDeclaration(NodeList<AnnotationExpr> annotations) { + this(Range.UNKNOWN, annotations); } - public BodyDeclaration(Range range, List<AnnotationExpr> annotations) { + public BodyDeclaration(Range range, NodeList<AnnotationExpr> annotations) { super(range); setAnnotations(annotations); } @Override - public final List<AnnotationExpr> getAnnotations() { - annotations = Utils.ensureNotNull(annotations); + public final NodeList<AnnotationExpr> getAnnotations() { return annotations; } @@ -61,8 +65,8 @@ public abstract class BodyDeclaration<T> extends Node implements NodeWithAnnotat */ @SuppressWarnings("unchecked") @Override - public final T setAnnotations(List<AnnotationExpr> annotations) { - this.annotations = annotations; + public final T setAnnotations(NodeList<AnnotationExpr> annotations) { + this.annotations = assertNotNull(annotations); setAsParentNodeOf(this.annotations); return (T) this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ClassOrInterfaceDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ClassOrInterfaceDeclaration.java index 4120d4a71..b01c085ca 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ClassOrInterfaceDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ClassOrInterfaceDeclaration.java @@ -23,6 +23,9 @@ package com.github.javaparser.ast.body; import com.github.javaparser.Range; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.expr.NameExpr; +import com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters; import com.github.javaparser.ast.type.TypeParameter; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.nodeTypes.NodeWithExtends; @@ -32,55 +35,69 @@ import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import java.util.EnumSet; -import java.util.List; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.ast.expr.NameExpr.*; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * @author Julio Vilmar Gesser */ -public final class ClassOrInterfaceDeclaration extends TypeDeclaration<ClassOrInterfaceDeclaration> - implements NodeWithImplements<ClassOrInterfaceDeclaration>, NodeWithExtends<ClassOrInterfaceDeclaration> { +public final class ClassOrInterfaceDeclaration extends TypeDeclaration<ClassOrInterfaceDeclaration> implements + NodeWithImplements<ClassOrInterfaceDeclaration>, + NodeWithExtends<ClassOrInterfaceDeclaration>, + NodeWithTypeParameters<ClassOrInterfaceDeclaration> { private boolean interface_; - private List<TypeParameter> typeParameters; + private NodeList<TypeParameter> typeParameters; // Can contain more than one item if this is an interface - private List<ClassOrInterfaceType> extendsList; + private NodeList<ClassOrInterfaceType> extendsList; - private List<ClassOrInterfaceType> implementsList; + private NodeList<ClassOrInterfaceType> implementsList; public ClassOrInterfaceDeclaration() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + false, + new NameExpr(), + new NodeList<>(), + new NodeList<>(), + new NodeList<>(), + new NodeList<>()); } public ClassOrInterfaceDeclaration(final EnumSet<Modifier> modifiers, final boolean isInterface, final String name) { - super(modifiers, name); - setInterface(isInterface); + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + isInterface, + name(name), + new NodeList<>(), + new NodeList<>(), + new NodeList<>(), + new NodeList<>()); } public ClassOrInterfaceDeclaration(final EnumSet<Modifier> modifiers, - final List<AnnotationExpr> annotations, final boolean isInterface, - final String name, - final List<TypeParameter> typeParameters, - final List<ClassOrInterfaceType> extendsList, - final List<ClassOrInterfaceType> implementsList, - final List<BodyDeclaration<?>> members) { - super(annotations, modifiers, name, members); - setInterface(isInterface); - setTypeParameters(typeParameters); - setExtends(extendsList); - setImplements(implementsList); + final NodeList<AnnotationExpr> annotations, final boolean isInterface, + final NameExpr name, + final NodeList<TypeParameter> typeParameters, + final NodeList<ClassOrInterfaceType> extendsList, + final NodeList<ClassOrInterfaceType> implementsList, + final NodeList<BodyDeclaration<?>> members) { + this(Range.UNKNOWN, modifiers, annotations, isInterface, name, typeParameters, extendsList, implementsList, members); } public ClassOrInterfaceDeclaration(Range range, final EnumSet<Modifier> modifiers, - final List<AnnotationExpr> annotations, final boolean isInterface, - final String name, - final List<TypeParameter> typeParameters, - final List<ClassOrInterfaceType> extendsList, - final List<ClassOrInterfaceType> implementsList, - final List<BodyDeclaration<?>> members) { + final NodeList<AnnotationExpr> annotations, final boolean isInterface, + final NameExpr name, + final NodeList<TypeParameter> typeParameters, + final NodeList<ClassOrInterfaceType> extendsList, + final NodeList<ClassOrInterfaceType> implementsList, + final NodeList<BodyDeclaration<?>> members) { super(range, annotations, modifiers, name, members); setInterface(isInterface); setTypeParameters(typeParameters); @@ -98,19 +115,17 @@ public final class ClassOrInterfaceDeclaration extends TypeDeclaration<ClassOrIn v.visit(this, arg); } - public List<ClassOrInterfaceType> getExtends() { - extendsList = ensureNotNull(extendsList); + @Override + public NodeList<ClassOrInterfaceType> getExtends() { return extendsList; } @Override - public List<ClassOrInterfaceType> getImplements() { - implementsList = ensureNotNull(implementsList); + public NodeList<ClassOrInterfaceType> getImplements() { return implementsList; } - public List<TypeParameter> getTypeParameters() { - typeParameters = ensureNotNull(typeParameters); + public NodeList<TypeParameter> getTypeParameters() { return typeParameters; } @@ -118,27 +133,16 @@ public final class ClassOrInterfaceDeclaration extends TypeDeclaration<ClassOrIn return interface_; } - /** - * - * @param extendsList a null value is currently treated as an empty list. This behavior could change - * in the future, so please avoid passing null - * @return - */ @Override - public ClassOrInterfaceDeclaration setExtends(final List<ClassOrInterfaceType> extendsList) { - this.extendsList = extendsList; + public ClassOrInterfaceDeclaration setExtends(final NodeList<ClassOrInterfaceType> extendsList) { + this.extendsList = assertNotNull(extendsList); setAsParentNodeOf(this.extendsList); return this; } - /** - * - * @param implementsList a null value is currently treated as an empty list. This behavior could change - * in the future, so please avoid passing null - */ @Override - public ClassOrInterfaceDeclaration setImplements(final List<ClassOrInterfaceType> implementsList) { - this.implementsList = implementsList; + public ClassOrInterfaceDeclaration setImplements(final NodeList<ClassOrInterfaceType> implementsList) { + this.implementsList = assertNotNull(implementsList); setAsParentNodeOf(this.implementsList); return this; } @@ -148,18 +152,10 @@ public final class ClassOrInterfaceDeclaration extends TypeDeclaration<ClassOrIn return this; } - /** - * - * @param typeParameters a null value is currently treated as an empty list. This behavior could change - * in the future, so please avoid passing null - */ - public ClassOrInterfaceDeclaration setTypeParameters(final List<TypeParameter> typeParameters) { - this.typeParameters = typeParameters; + @Override + public ClassOrInterfaceDeclaration setTypeParameters(final NodeList<TypeParameter> typeParameters) { + this.typeParameters = assertNotNull(typeParameters); setAsParentNodeOf(this.typeParameters); return this; } - - - - } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java index 4a9cd2a2a..ad4394ff0 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/ConstructorDeclaration.java @@ -24,6 +24,7 @@ package com.github.javaparser.ast.body; import com.github.javaparser.Range; import com.github.javaparser.ast.AccessSpecifier; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.type.TypeParameter; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.AnnotationExpr; @@ -35,59 +36,82 @@ import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import java.util.EnumSet; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.ast.expr.NameExpr.*; +import static com.github.javaparser.ast.expr.NameExpr.name; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser */ -public final class ConstructorDeclaration extends BodyDeclaration<ConstructorDeclaration> - implements NodeWithJavaDoc<ConstructorDeclaration>, NodeWithDeclaration, - NodeWithName<ConstructorDeclaration>, NodeWithModifiers<ConstructorDeclaration>, - NodeWithParameters<ConstructorDeclaration>, NodeWithThrowable<ConstructorDeclaration>, - NodeWithBlockStmt<ConstructorDeclaration> { +public final class ConstructorDeclaration extends BodyDeclaration<ConstructorDeclaration> implements + NodeWithJavaDoc<ConstructorDeclaration>, + NodeWithDeclaration, + NodeWithName<ConstructorDeclaration>, + NodeWithModifiers<ConstructorDeclaration>, + NodeWithParameters<ConstructorDeclaration>, + NodeWithThrowable<ConstructorDeclaration>, + NodeWithBlockStmt<ConstructorDeclaration>, + NodeWithTypeParameters<ConstructorDeclaration> { private EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); - private List<TypeParameter> typeParameters; + private NodeList<TypeParameter> typeParameters; private NameExpr name; - private List<Parameter> parameters; + private NodeList<Parameter> parameters; - private List<ReferenceType> throws_; + private NodeList<ReferenceType<?>> throws_; private BlockStmt body; public ConstructorDeclaration() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new NodeList<>(), + new NameExpr(), + new NodeList<>(), + new NodeList<>(), + new BlockStmt()); } public ConstructorDeclaration(EnumSet<Modifier> modifiers, String name) { - setModifiers(modifiers); - setName(name); + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + new NodeList<>(), + name(name), + new NodeList<>(), + new NodeList<>(), + new BlockStmt()); } - public ConstructorDeclaration(EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, - List<TypeParameter> typeParameters, - String name, List<Parameter> parameters, List<ReferenceType> throws_, + public ConstructorDeclaration(EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, + NodeList<TypeParameter> typeParameters, + NameExpr name, NodeList<Parameter> parameters, NodeList<ReferenceType<?>> throws_, BlockStmt block) { - super(annotations); - setModifiers(modifiers); - setTypeParameters(typeParameters); - setName(name); - setParameters(parameters); - setThrows(throws_); - setBody(block); + this(Range.UNKNOWN, + modifiers, + annotations, + typeParameters, + name, + parameters, + throws_, + block); } public ConstructorDeclaration(Range range, EnumSet<Modifier> modifiers, - List<AnnotationExpr> annotations, List<TypeParameter> typeParameters, String name, - List<Parameter> parameters, List<ReferenceType> throws_, BlockStmt block) { + NodeList<AnnotationExpr> annotations, NodeList<TypeParameter> typeParameters, NameExpr name, + NodeList<Parameter> parameters, NodeList<ReferenceType<?>> throws_, BlockStmt block) { super(range, annotations); setModifiers(modifiers); setTypeParameters(typeParameters); - setName(name); + setNameExpr(name); setParameters(parameters); setThrows(throws_); setBody(block); @@ -116,7 +140,7 @@ public final class ConstructorDeclaration extends BodyDeclaration<ConstructorDec @Override public String getName() { - return name == null ? null : name.getName(); + return name.getName(); } public NameExpr getNameExpr() { @@ -124,56 +148,53 @@ public final class ConstructorDeclaration extends BodyDeclaration<ConstructorDec } @Override - public List<Parameter> getParameters() { - parameters = ensureNotNull(parameters); + public NodeList<Parameter> getParameters() { return parameters; } @Override - public List<ReferenceType> getThrows() { - throws_ = ensureNotNull(throws_); + public NodeList<ReferenceType<?>> getThrows() { return throws_; } - public List<TypeParameter> getTypeParameters() { - typeParameters = ensureNotNull(typeParameters); + public NodeList<TypeParameter> getTypeParameters() { return typeParameters; } @Override public ConstructorDeclaration setModifiers(EnumSet<Modifier> modifiers) { - this.modifiers = modifiers; + this.modifiers = assertNotNull(modifiers); return this; } @Override public ConstructorDeclaration setName(String name) { - setNameExpr(new NameExpr(name)); + setNameExpr(new NameExpr(assertNotNull(name))); return this; } public ConstructorDeclaration setNameExpr(NameExpr name) { - this.name = name; + this.name = assertNotNull(name); setAsParentNodeOf(this.name); return this; } @Override - public ConstructorDeclaration setParameters(List<Parameter> parameters) { - this.parameters = parameters; + public ConstructorDeclaration setParameters(NodeList<Parameter> parameters) { + this.parameters = assertNotNull(parameters); setAsParentNodeOf(this.parameters); return this; } @Override - public ConstructorDeclaration setThrows(List<ReferenceType> throws_) { - this.throws_ = throws_; + public ConstructorDeclaration setThrows(NodeList<ReferenceType<?>> throws_) { + this.throws_ = assertNotNull(throws_); setAsParentNodeOf(this.throws_); return this; } - public ConstructorDeclaration setTypeParameters(List<TypeParameter> typeParameters) { - this.typeParameters = typeParameters; + public ConstructorDeclaration setTypeParameters(NodeList<TypeParameter> typeParameters) { + this.typeParameters = assertNotNull(typeParameters); setAsParentNodeOf(this.typeParameters); return this; } @@ -235,13 +256,15 @@ public final class ConstructorDeclaration extends BodyDeclaration<ConstructorDec } @Override - public JavadocComment getJavaDoc() { - if (getComment() instanceof JavadocComment) { - return (JavadocComment) getComment(); + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } } - return null; + return none(); } - + @Override public BlockStmt getBody() { return body; @@ -249,7 +272,7 @@ public final class ConstructorDeclaration extends BodyDeclaration<ConstructorDec @Override public ConstructorDeclaration setBody(BlockStmt body) { - this.body = body; + this.body = assertNotNull(body); setAsParentNodeOf(body); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyMemberDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyMemberDeclaration.java index 102eb7aa4..ec16e4792 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyMemberDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyMemberDeclaration.java @@ -22,11 +22,17 @@ package com.github.javaparser.ast.body; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.utils.Utils.none; + /** * @author Julio Vilmar Gesser */ @@ -34,11 +40,11 @@ public final class EmptyMemberDeclaration extends BodyDeclaration<EmptyMemberDec implements NodeWithJavaDoc<EmptyMemberDeclaration> { public EmptyMemberDeclaration() { - super(null); + this(Range.UNKNOWN); } public EmptyMemberDeclaration(Range range) { - super(range, null); + super(range, new NodeList<>()); } @Override @@ -52,10 +58,12 @@ public final class EmptyMemberDeclaration extends BodyDeclaration<EmptyMemberDec } @Override - public JavadocComment getJavaDoc() { - if(getComment() instanceof JavadocComment){ - return (JavadocComment) getComment(); + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } } - return null; + return none(); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyTypeDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyTypeDeclaration.java index 3a774de99..0c8cffe31 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyTypeDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EmptyTypeDeclaration.java @@ -25,20 +25,24 @@ import java.util.EnumSet; import com.github.javaparser.Range; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.ast.NodeList.*; + /** * @author Julio Vilmar Gesser */ public final class EmptyTypeDeclaration extends TypeDeclaration<EmptyTypeDeclaration> { public EmptyTypeDeclaration() { - super(null, EnumSet.noneOf(Modifier.class), null, null); + this(Range.UNKNOWN); } public EmptyTypeDeclaration(Range range) { - super(range, null, EnumSet.noneOf(Modifier.class), null, null); + super(range, new NodeList<>(), EnumSet.noneOf(Modifier.class), new NameExpr(), new NodeList<>()); } @Override diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumConstantDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumConstantDeclaration.java index 646f6c287..bcb8b9ed5 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumConstantDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumConstantDeclaration.java @@ -21,54 +21,60 @@ package com.github.javaparser.ast.body; -import static com.github.javaparser.ast.expr.NameExpr.*; -import static com.github.javaparser.utils.Utils.ensureNotNull; - -import java.util.List; +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.expr.Expression; -import com.github.javaparser.ast.expr.NameExpr; +import com.github.javaparser.ast.nodeTypes.NodeWithArguments; import com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc; import com.github.javaparser.ast.nodeTypes.NodeWithName; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - -import static com.github.javaparser.utils.Utils.ensureNotNull; +import java.util.Optional; /** * @author Julio Vilmar Gesser */ -public final class EnumConstantDeclaration extends BodyDeclaration<EnumConstantDeclaration> - implements NodeWithJavaDoc<EnumConstantDeclaration>, NodeWithName<EnumConstantDeclaration> { +public final class EnumConstantDeclaration extends BodyDeclaration<EnumConstantDeclaration> implements + NodeWithJavaDoc<EnumConstantDeclaration>, + NodeWithName<EnumConstantDeclaration>, + NodeWithArguments<EnumConstantDeclaration> { private String name; - private List<Expression> args; + private NodeList<Expression> args; - private List<BodyDeclaration<?>> classBody; + private NodeList<BodyDeclaration<?>> classBody; public EnumConstantDeclaration() { + this(Range.UNKNOWN, + new NodeList<>(), + "empty", + new NodeList<>(), + new NodeList<>()); } public EnumConstantDeclaration(String name) { - setName(name); + this(Range.UNKNOWN, + new NodeList<>(), + name, + new NodeList<>(), + new NodeList<>()); } - public EnumConstantDeclaration(List<AnnotationExpr> annotations, String name, List<Expression> args, - List<BodyDeclaration<?>> classBody) { - super(annotations); - setName(name); - setArgs(args); - setClassBody(classBody); + public EnumConstantDeclaration(NodeList<AnnotationExpr> annotations, String name, NodeList<Expression> args, + NodeList<BodyDeclaration<?>> classBody) { + this(Range.UNKNOWN, annotations, name, args, classBody); } - public EnumConstantDeclaration(Range range, List<AnnotationExpr> annotations, String name, List<Expression> args, - List<BodyDeclaration<?>> classBody) { + public EnumConstantDeclaration(Range range, NodeList<AnnotationExpr> annotations, String name, NodeList<Expression> args, + NodeList<BodyDeclaration<?>> classBody) { super(range, annotations); setName(name); setArgs(args); @@ -85,13 +91,11 @@ public final class EnumConstantDeclaration extends BodyDeclaration<EnumConstantD v.visit(this, arg); } - public List<Expression> getArgs() { - args = ensureNotNull(args); + public NodeList<Expression> getArgs() { return args; } - public List<BodyDeclaration<?>> getClassBody() { - classBody = ensureNotNull(classBody); + public NodeList<BodyDeclaration<?>> getClassBody() { return classBody; } @@ -100,34 +104,31 @@ public final class EnumConstantDeclaration extends BodyDeclaration<EnumConstantD return name; } - public EnumConstantDeclaration setArgs(List<Expression> args) { - this.args = args; + public EnumConstantDeclaration setArgs(NodeList<Expression> args) { + this.args = assertNotNull(args); setAsParentNodeOf(this.args); return this; } - public EnumConstantDeclaration setClassBody(List<BodyDeclaration<?>> classBody) { - this.classBody = classBody; + public EnumConstantDeclaration setClassBody(NodeList<BodyDeclaration<?>> classBody) { + this.classBody = assertNotNull(classBody); setAsParentNodeOf(this.classBody); return this; } @Override public EnumConstantDeclaration setName(String name) { - this.name = name; + this.name = assertNotNull(name); return this; } @Override - public JavadocComment getJavaDoc() { - if(getComment() instanceof JavadocComment){ - return (JavadocComment) getComment(); + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } } - return null; - } - - public EnumConstantDeclaration addArgument(String valueExpr) { - getArgs().add(name(valueExpr)); - return this; + return none(); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumDeclaration.java index 0ad3089b6..94ab8b69c 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/EnumDeclaration.java @@ -21,14 +21,16 @@ package com.github.javaparser.ast.body; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.ast.expr.NameExpr.*; +import static com.github.javaparser.utils.Utils.assertNotNull; import java.util.EnumSet; -import java.util.List; import com.github.javaparser.Range; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; +import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.nodeTypes.NodeWithImplements; import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.visitor.GenericVisitor; @@ -37,31 +39,48 @@ import com.github.javaparser.ast.visitor.VoidVisitor; /** * @author Julio Vilmar Gesser */ -public final class EnumDeclaration extends TypeDeclaration<EnumDeclaration> - implements NodeWithImplements<EnumDeclaration> { +public final class EnumDeclaration extends TypeDeclaration<EnumDeclaration> implements + NodeWithImplements<EnumDeclaration> { - private List<ClassOrInterfaceType> implementsList; + private NodeList<ClassOrInterfaceType> implementsList; - private List<EnumConstantDeclaration> entries; + private NodeList<EnumConstantDeclaration> entries; public EnumDeclaration() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new NameExpr(), + new NodeList<>(), + new NodeList<>(), + new NodeList<>()); } public EnumDeclaration(EnumSet<Modifier> modifiers, String name) { - super(modifiers, name); + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + name(name), + new NodeList<>(), + new NodeList<>(), + new NodeList<>()); } - public EnumDeclaration(EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, String name, - List<ClassOrInterfaceType> implementsList, List<EnumConstantDeclaration> entries, - List<BodyDeclaration<?>> members) { - super(annotations, modifiers, name, members); - setImplements(implementsList); - setEntries(entries); + public EnumDeclaration(EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, NameExpr name, + NodeList<ClassOrInterfaceType> implementsList, NodeList<EnumConstantDeclaration> entries, + NodeList<BodyDeclaration<?>> members) { + this(Range.UNKNOWN, + modifiers, + annotations, + name, + implementsList, + entries, + members); } - public EnumDeclaration(Range range, EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, String name, - List<ClassOrInterfaceType> implementsList, List<EnumConstantDeclaration> entries, - List<BodyDeclaration<?>> members) { + public EnumDeclaration(Range range, EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, NameExpr name, + NodeList<ClassOrInterfaceType> implementsList, NodeList<EnumConstantDeclaration> entries, + NodeList<BodyDeclaration<?>> members) { super(range, annotations, modifiers, name, members); setImplements(implementsList); setEntries(entries); @@ -78,34 +97,30 @@ public final class EnumDeclaration extends TypeDeclaration<EnumDeclaration> v.visit(this, arg); } - public List<EnumConstantDeclaration> getEntries() { - entries = ensureNotNull(entries); + public NodeList<EnumConstantDeclaration> getEntries() { return entries; } @Override - public List<ClassOrInterfaceType> getImplements() { - implementsList = ensureNotNull(implementsList); + public NodeList<ClassOrInterfaceType> getImplements() { return implementsList; } - public EnumDeclaration setEntries(List<EnumConstantDeclaration> entries) { - this.entries = entries; + public EnumDeclaration setEntries(NodeList<EnumConstantDeclaration> entries) { + this.entries = assertNotNull(entries); setAsParentNodeOf(this.entries); return this; } @Override - public EnumDeclaration setImplements(List<ClassOrInterfaceType> implementsList) { - this.implementsList = implementsList; + public EnumDeclaration setImplements(NodeList<ClassOrInterfaceType> implementsList) { + this.implementsList = assertNotNull(implementsList); setAsParentNodeOf(this.implementsList); return this; } - - public EnumConstantDeclaration addEnumConstant(String name) { - EnumConstantDeclaration enumConstant = new EnumConstantDeclaration(name); + EnumConstantDeclaration enumConstant = new EnumConstantDeclaration(assertNotNull(name)); getEntries().add(enumConstant); enumConstant.setParentNode(this); return enumConstant; diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/FieldDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/FieldDeclaration.java index aa04a5230..eb4fecf87 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/FieldDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/FieldDeclaration.java @@ -21,16 +21,18 @@ package com.github.javaparser.ast.body; +import static com.github.javaparser.ast.NodeList.*; import static com.github.javaparser.ast.expr.NameExpr.*; -import static com.github.javaparser.utils.Utils.ensureNotNull; import java.util.ArrayList; import java.util.EnumSet; import java.util.List; +import java.util.Optional; import com.github.javaparser.Range; import com.github.javaparser.ast.ArrayBracketPair; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.expr.AssignExpr; @@ -39,12 +41,14 @@ import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.nodeTypes.*; import com.github.javaparser.ast.stmt.BlockStmt; import com.github.javaparser.ast.stmt.ReturnStmt; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import static com.github.javaparser.ast.Modifier.PUBLIC; import static com.github.javaparser.ast.type.VoidType.VOID_TYPE; +import static com.github.javaparser.utils.Utils.*; /** * @author Julio Vilmar Gesser @@ -59,38 +63,49 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im private Type elementType; - private List<VariableDeclarator> variables; + private NodeList<VariableDeclarator> variables; - private List<ArrayBracketPair> arrayBracketPairsAfterElementType; + private NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType; public FieldDeclaration() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new ClassOrInterfaceType(), + new NodeList<>(), + new NodeList<>()); } - public FieldDeclaration(EnumSet<Modifier> modifiers, Type elementType, VariableDeclarator variable) { - setModifiers(modifiers); - setElementType(elementType); - List<VariableDeclarator> aux = new ArrayList<>(); - aux.add(variable); - setVariables(aux); + public FieldDeclaration(EnumSet<Modifier> modifiers, Type<?> elementType, VariableDeclarator variable) { + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + elementType, + nodeList(variable), + new NodeList<>()); } - public FieldDeclaration(EnumSet<Modifier> modifiers, Type elementType, List<VariableDeclarator> variables) { - setModifiers(modifiers); - setElementType(elementType); - setVariables(variables); + public FieldDeclaration(EnumSet<Modifier> modifiers, Type<?> elementType, NodeList<VariableDeclarator> variables) { + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + elementType, + variables, + new NodeList<>()); } - public FieldDeclaration(EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, Type elementType, List<ArrayBracketPair> arrayBracketPairsAfterElementType, - List<VariableDeclarator> variables) { - super(annotations); - setModifiers(modifiers); - setElementType(elementType); - setVariables(variables); - setArrayBracketPairsAfterElementType(arrayBracketPairsAfterElementType); + public FieldDeclaration(EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, Type<?> elementType, NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType, + NodeList<VariableDeclarator> variables) { + this(Range.UNKNOWN, + modifiers, + annotations, + elementType, + variables, + arrayBracketPairsAfterElementType); } - public FieldDeclaration(Range range, EnumSet<Modifier> modifiers, List<AnnotationExpr> annotations, Type elementType, - List<VariableDeclarator> variables, List<ArrayBracketPair> arrayBracketPairsAfterElementType) { + public FieldDeclaration(Range range, EnumSet<Modifier> modifiers, NodeList<AnnotationExpr> annotations, Type<?> elementType, + NodeList<VariableDeclarator> variables, NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType) { super(range, annotations); setModifiers(modifiers); setElementType(elementType); @@ -109,11 +124,9 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im * variable declarator * @return instance of {@link FieldDeclaration} */ - public static FieldDeclaration create(EnumSet<Modifier> modifiers, Type type, + public static FieldDeclaration create(EnumSet<Modifier> modifiers, Type<?> type, VariableDeclarator variable) { - List<VariableDeclarator> variables = new ArrayList<>(); - variables.add(variable); - return new FieldDeclaration(modifiers, type, variables); + return new FieldDeclaration(modifiers, type, new NodeList<VariableDeclarator>().add(variable)); } /** @@ -127,9 +140,10 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im * field name * @return instance of {@link FieldDeclaration} */ - public static FieldDeclaration create(EnumSet<Modifier> modifiers, Type type, String name) { - VariableDeclaratorId id = new VariableDeclaratorId(name); - VariableDeclarator variable = new VariableDeclarator(id); + public static FieldDeclaration create(EnumSet<Modifier> modifiers, Type<?> type, String name) { + assertNotNull(type); + VariableDeclaratorId id = new VariableDeclaratorId(assertNotNull(name)); + VariableDeclarator variable = new VariableDeclarator(assertNotNull(id)); return create(modifiers, type, variable); } @@ -155,32 +169,34 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im } @Override - public List<VariableDeclarator> getVariables() { - variables = ensureNotNull(variables); + public NodeList<VariableDeclarator> getVariables() { return variables; } @Override public FieldDeclaration setModifiers(EnumSet<Modifier> modifiers) { - this.modifiers = modifiers; + this.modifiers = assertNotNull(modifiers); return this; } @Override - public FieldDeclaration setVariables(List<VariableDeclarator> variables) { - this.variables = variables; + public FieldDeclaration setVariables(NodeList<VariableDeclarator> variables) { + this.variables = assertNotNull(variables); setAsParentNodeOf(this.variables); return this; } @Override - public JavadocComment getJavaDoc() { - if (getComment() instanceof JavadocComment) { - return (JavadocComment) getComment(); + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } } - return null; + return none(); } + /** * Create a getter for this field, <b>will only work if this field declares only 1 identifier and if this field is * already added to a ClassOrInterfaceDeclaration</b> @@ -208,7 +224,7 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im getter = parentEnum.addMethod("get" + fieldNameUpper, PUBLIC); getter.setType(variable.getType()); BlockStmt blockStmt = new BlockStmt(); - getter.setBody(blockStmt); + getter.setBody(some(blockStmt)); blockStmt.addStatement(new ReturnStmt(name(fieldName))); return getter; } @@ -242,7 +258,7 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im setter.setType(VOID_TYPE); setter.getParameters().add(new Parameter(variable.getType(), new VariableDeclaratorId(fieldName))); BlockStmt blockStmt2 = new BlockStmt(); - setter.setBody(blockStmt2); + setter.setBody(some(blockStmt2)); blockStmt2.addStatement(new AssignExpr(new NameExpr("this." + fieldName), new NameExpr(fieldName), Operator.assign)); return setter; } @@ -255,7 +271,7 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im @Override public FieldDeclaration setElementType(final Type elementType) { - this.elementType = elementType; + this.elementType = assertNotNull(elementType); setAsParentNodeOf(this.elementType); return this; } @@ -263,14 +279,13 @@ public final class FieldDeclaration extends BodyDeclaration<FieldDeclaration> im /** * @return the array brackets in this position: <code>class C { int[] abc; }</code> */ - public List<ArrayBracketPair> getArrayBracketPairsAfterElementType() { - arrayBracketPairsAfterElementType = ensureNotNull(arrayBracketPairsAfterElementType); + public NodeList<ArrayBracketPair> getArrayBracketPairsAfterElementType() { return arrayBracketPairsAfterElementType; } @Override - public FieldDeclaration setArrayBracketPairsAfterElementType(List<ArrayBracketPair> arrayBracketPairsAfterType) { - this.arrayBracketPairsAfterElementType = arrayBracketPairsAfterType; + public FieldDeclaration setArrayBracketPairsAfterElementType(NodeList<ArrayBracketPair> arrayBracketPairsAfterType) { + this.arrayBracketPairsAfterElementType = assertNotNull(arrayBracketPairsAfterType); setAsParentNodeOf(arrayBracketPairsAfterType); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/InitializerDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/InitializerDeclaration.java index adb893f03..1763bbf59 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/InitializerDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/InitializerDeclaration.java @@ -22,12 +22,19 @@ package com.github.javaparser.ast.body; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc; import com.github.javaparser.ast.stmt.BlockStmt; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; + /** * @author Julio Vilmar Gesser */ @@ -39,16 +46,15 @@ public final class InitializerDeclaration extends BodyDeclaration<InitializerDec private BlockStmt block; public InitializerDeclaration() { + this(Range.UNKNOWN, false, new BlockStmt()); } public InitializerDeclaration(boolean isStatic, BlockStmt block) { - super(null); - setStatic(isStatic); - setBlock(block); + this(Range.UNKNOWN, isStatic, block); } public InitializerDeclaration(Range range, boolean isStatic, BlockStmt block) { - super(range, null); + super(range, new NodeList<>()); setStatic(isStatic); setBlock(block); } @@ -72,7 +78,7 @@ public final class InitializerDeclaration extends BodyDeclaration<InitializerDec } public InitializerDeclaration setBlock(BlockStmt block) { - this.block = block; + this.block = assertNotNull(block); setAsParentNodeOf(this.block); return this; } @@ -83,10 +89,12 @@ public final class InitializerDeclaration extends BodyDeclaration<InitializerDec } @Override - public JavadocComment getJavaDoc() { - if(getComment() instanceof JavadocComment){ - return (JavadocComment) getComment(); + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } } - return null; + return none(); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/MethodDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/MethodDeclaration.java index a89103a3b..58144f4b7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/MethodDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/MethodDeclaration.java @@ -21,35 +21,31 @@ package com.github.javaparser.ast.body; +import static com.github.javaparser.ast.expr.NameExpr.*; import static com.github.javaparser.ast.type.ArrayType.*; import static com.github.javaparser.ast.type.ArrayType.wrapInArrayTypes; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; import java.util.EnumSet; -import java.util.List; +import java.util.Optional; import com.github.javaparser.Range; -import com.github.javaparser.ast.AccessSpecifier; -import com.github.javaparser.ast.ArrayBracketPair; -import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.*; import com.github.javaparser.ast.nodeTypes.*; +import com.github.javaparser.ast.stmt.BlockStmt; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.TypeParameter; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.expr.NameExpr; -import com.github.javaparser.ast.nodeTypes.*; -import com.github.javaparser.ast.stmt.BlockStmt; import com.github.javaparser.ast.type.ReferenceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import com.github.javaparser.utils.Pair; -import java.util.EnumSet; -import java.util.List; - -import static com.github.javaparser.utils.Utils.ensureNotNull; - /** * @author Julio Vilmar Gesser */ @@ -57,83 +53,110 @@ public final class MethodDeclaration extends BodyDeclaration<MethodDeclaration> NodeWithJavaDoc<MethodDeclaration>, NodeWithDeclaration, NodeWithName<MethodDeclaration>, - NodeWithType<MethodDeclaration>, + NodeWithType<MethodDeclaration, Type<?>>, NodeWithElementType<MethodDeclaration>, NodeWithModifiers<MethodDeclaration>, NodeWithParameters<MethodDeclaration>, NodeWithThrowable<MethodDeclaration>, - NodeWithBlockStmt<MethodDeclaration> { + NodeWithTypeParameters<MethodDeclaration> { private EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); - private List<TypeParameter> typeParameters; + private NodeList<TypeParameter> typeParameters; private Type elementType; private NameExpr name; - private List<Parameter> parameters; + private NodeList<Parameter> parameters; - private List<ReferenceType> throws_; + private NodeList<ReferenceType<?>> throws_; - private BlockStmt body; + private Optional<BlockStmt> body; private boolean isDefault = false; - private List<ArrayBracketPair> arrayBracketPairsAfterType; + private NodeList<ArrayBracketPair> arrayBracketPairsAfterType; - private List<ArrayBracketPair> arrayBracketPairsAfterParameterList; + private NodeList<ArrayBracketPair> arrayBracketPairsAfterParameterList; public MethodDeclaration() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new NodeList<>(), + new ClassOrInterfaceType(), + new NodeList<>(), + new NameExpr(), + new NodeList<>(), + new NodeList<>(), + new NodeList<>(), + none()); } public MethodDeclaration(final EnumSet<Modifier> modifiers, final Type elementType, final String name) { - setModifiers(modifiers); - setElementType(elementType); - setName(name); + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + new NodeList<>(), + elementType, + new NodeList<>(), + name(name), + new NodeList<>(), + new NodeList<>(), + new NodeList<>(), + none()); } public MethodDeclaration(final EnumSet<Modifier> modifiers, final Type elementType, final String name, - final List<Parameter> parameters) { - setModifiers(modifiers); - setElementType(elementType); - setName(name); - setParameters(parameters); + final NodeList<Parameter> parameters) { + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + new NodeList<>(), + elementType, + new NodeList<>(), + name(name), + parameters, + new NodeList<>(), + new NodeList<>(), + none()); } public MethodDeclaration(final EnumSet<Modifier> modifiers, - final List<AnnotationExpr> annotations, - final List<TypeParameter> typeParameters, + final NodeList<AnnotationExpr> annotations, + final NodeList<TypeParameter> typeParameters, final Type elementType, - final List<ArrayBracketPair> arrayBracketPairsAfterElementType, + final NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType, final String name, - final List<Parameter> parameters, - final List<ArrayBracketPair> arrayBracketPairsAfterParameterList, - final List<ReferenceType> throws_, - final BlockStmt body) { - super(annotations); - setModifiers(modifiers); - setTypeParameters(typeParameters); - setElementType(elementType); - setName(name); - setParameters(parameters); - setArrayBracketPairsAfterElementType(arrayBracketPairsAfterElementType); - setArrayBracketPairsAfterParameterList(arrayBracketPairsAfterParameterList); - setThrows(throws_); - setBody(body); + final NodeList<Parameter> parameters, + final NodeList<ArrayBracketPair> arrayBracketPairsAfterParameterList, + final NodeList<ReferenceType<?>> throws_, + final Optional<BlockStmt> body) { + this(Range.UNKNOWN, + modifiers, + annotations, + typeParameters, + elementType, + arrayBracketPairsAfterElementType, + name(name), + parameters, + arrayBracketPairsAfterParameterList, + throws_, + body); } public MethodDeclaration(Range range, final EnumSet<Modifier> modifiers, - final List<AnnotationExpr> annotations, - final List<TypeParameter> typeParameters, + final NodeList<AnnotationExpr> annotations, + final NodeList<TypeParameter> typeParameters, final Type elementType, - final List<ArrayBracketPair> arrayBracketPairsAfterElementType, + final NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType, final NameExpr nameExpr, - final List<Parameter> parameters, - final List<ArrayBracketPair> arrayBracketPairsAfterParameterList, - final List<ReferenceType> throws_, - final BlockStmt body) { + final NodeList<Parameter> parameters, + final NodeList<ArrayBracketPair> arrayBracketPairsAfterParameterList, + final NodeList<ReferenceType<?>> throws_, + final Optional<BlockStmt> body) { super(range, annotations); setModifiers(modifiers); setTypeParameters(typeParameters); @@ -156,8 +179,7 @@ public final class MethodDeclaration extends BodyDeclaration<MethodDeclaration> v.visit(this, arg); } - @Override - public BlockStmt getBody() { + public Optional<BlockStmt> getBody() { return body; } @@ -182,14 +204,12 @@ public final class MethodDeclaration extends BodyDeclaration<MethodDeclaration> } @Override - public List<Parameter> getParameters() { - parameters = ensureNotNull(parameters); + public NodeList<Parameter> getParameters() { return parameters; } @Override - public List<ReferenceType> getThrows() { - throws_ = ensureNotNull(throws_); + public NodeList<ReferenceType<?>> getThrows() { return throws_; } @@ -205,68 +225,68 @@ public final class MethodDeclaration extends BodyDeclaration<MethodDeclaration> return elementType; } - public List<TypeParameter> getTypeParameters() { - typeParameters = ensureNotNull(typeParameters); + @Override + public NodeList<TypeParameter> getTypeParameters() { return typeParameters; } - @Override - public MethodDeclaration setBody(final BlockStmt body) { - this.body = body; + public MethodDeclaration setBody(final Optional<BlockStmt> body) { + this.body = assertNotNull(body); setAsParentNodeOf(this.body); return this; } @Override public MethodDeclaration setModifiers(final EnumSet<Modifier> modifiers) { - this.modifiers = modifiers; + this.modifiers = assertNotNull(modifiers); return this; } @Override public MethodDeclaration setName(final String name) { - setNameExpr(new NameExpr(name)); + setNameExpr(new NameExpr(assertNotNull(name))); return this; } public MethodDeclaration setNameExpr(final NameExpr name) { - this.name = name; + this.name = assertNotNull(name); setAsParentNodeOf(this.name); return this; } @Override - public MethodDeclaration setParameters(final List<Parameter> parameters) { - this.parameters = parameters; + public MethodDeclaration setParameters(final NodeList<Parameter> parameters) { + this.parameters = assertNotNull(parameters); setAsParentNodeOf(this.parameters); return this; } @Override - public MethodDeclaration setThrows(final List<ReferenceType> throws_) { - this.throws_ = throws_; + public MethodDeclaration setThrows(final NodeList<ReferenceType<?>> throws_) { + this.throws_ = assertNotNull(throws_); setAsParentNodeOf(this.throws_); return this; } @Override public MethodDeclaration setType(final Type type) { - Pair<Type, List<ArrayBracketPair>> typeListPair = unwrapArrayTypes(type); + Pair<Type, NodeList<ArrayBracketPair>> typeListPair = unwrapArrayTypes(assertNotNull(type)); setElementType(typeListPair.a); setArrayBracketPairsAfterElementType(typeListPair.b); - setArrayBracketPairsAfterParameterList(null); + setArrayBracketPairsAfterParameterList(new NodeList<>()); return this; } @Override public MethodDeclaration setElementType(final Type elementType) { - this.elementType = elementType; + this.elementType = assertNotNull(elementType); setAsParentNodeOf(this.elementType); return this; } - public MethodDeclaration setTypeParameters(final List<TypeParameter> typeParameters) { - this.typeParameters = typeParameters; + @Override + public MethodDeclaration setTypeParameters(final NodeList<TypeParameter> typeParameters) { + this.typeParameters = assertNotNull(typeParameters); setAsParentNodeOf(typeParameters); return this; } @@ -361,24 +381,25 @@ public final class MethodDeclaration extends BodyDeclaration<MethodDeclaration> } @Override - public JavadocComment getJavaDoc() { - if (getComment() instanceof JavadocComment) { - return (JavadocComment) getComment(); + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } } - return null; + return none(); } - + /** * @return the array brackets in this position: <code>class C { int[] abc; }</code> */ - public List<ArrayBracketPair> getArrayBracketPairsAfterElementType() { - arrayBracketPairsAfterType = ensureNotNull(arrayBracketPairsAfterType); + public NodeList<ArrayBracketPair> getArrayBracketPairsAfterElementType() { return arrayBracketPairsAfterType; } @Override - public MethodDeclaration setArrayBracketPairsAfterElementType(List<ArrayBracketPair> arrayBracketPairsAfterType) { - this.arrayBracketPairsAfterType = arrayBracketPairsAfterType; + public MethodDeclaration setArrayBracketPairsAfterElementType(NodeList<ArrayBracketPair> arrayBracketPairsAfterType) { + this.arrayBracketPairsAfterType = assertNotNull(arrayBracketPairsAfterType); setAsParentNodeOf(arrayBracketPairsAfterType); return this; } @@ -386,14 +407,19 @@ public final class MethodDeclaration extends BodyDeclaration<MethodDeclaration> /** * @return the array brackets in this position: <code>int abc()[] {...}</code> */ - public List<ArrayBracketPair> getArrayBracketPairsAfterParameterList() { - arrayBracketPairsAfterParameterList = ensureNotNull(arrayBracketPairsAfterParameterList); + public NodeList<ArrayBracketPair> getArrayBracketPairsAfterParameterList() { return arrayBracketPairsAfterParameterList; } - public MethodDeclaration setArrayBracketPairsAfterParameterList(List<ArrayBracketPair> arrayBracketPairsAfterParameterList) { - this.arrayBracketPairsAfterParameterList = arrayBracketPairsAfterParameterList; + public MethodDeclaration setArrayBracketPairsAfterParameterList(NodeList<ArrayBracketPair> arrayBracketPairsAfterParameterList) { + this.arrayBracketPairsAfterParameterList = assertNotNull(arrayBracketPairsAfterParameterList); setAsParentNodeOf(arrayBracketPairsAfterParameterList); return this; } + + public BlockStmt createBody() { + BlockStmt block = new BlockStmt(); + setBody(some(block)); + return block; + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/Parameter.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/Parameter.java index d66b39a00..5e7bb3cf2 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/Parameter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/Parameter.java @@ -25,9 +25,11 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.ArrayBracketPair; import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.nodeTypes.*; import com.github.javaparser.ast.type.ArrayType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; @@ -35,38 +37,49 @@ import com.github.javaparser.utils.Pair; import static com.github.javaparser.ast.type.ArrayType.wrapInArrayTypes; import java.util.EnumSet; -import java.util.List; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * @author Julio Vilmar Gesser */ public final class Parameter extends Node implements - NodeWithType<Parameter>, + NodeWithType<Parameter, Type<?>>, NodeWithElementType<Parameter>, NodeWithAnnotations<Parameter>, NodeWithName<Parameter>, NodeWithModifiers<Parameter> { - private Type elementType; + private Type<?> elementType; private boolean isVarArgs; private EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); - private List<AnnotationExpr> annotations; + private NodeList<AnnotationExpr> annotations = new NodeList<>(); private VariableDeclaratorId id; - private List<ArrayBracketPair> arrayBracketPairsAfterType; + private NodeList<ArrayBracketPair> arrayBracketPairsAfterType; public Parameter() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new ClassOrInterfaceType(), + new NodeList<>(), + false, + new VariableDeclaratorId()); } - public Parameter(Type elementType, VariableDeclaratorId id) { - setId(id); - setElementType(elementType); + public Parameter(Type<?> elementType, VariableDeclaratorId id) { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + elementType, + new NodeList<>(), + false, + id); } /** @@ -79,20 +92,30 @@ public final class Parameter extends Node implements * @return instance of {@link Parameter} */ public static Parameter create(Type elementType, String name) { - return new Parameter(elementType, new VariableDeclaratorId(name)); + return new Parameter(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + elementType, + new NodeList<>(), + false, + new VariableDeclaratorId(name)); } public Parameter(EnumSet<Modifier> modifiers, Type elementType, VariableDeclaratorId id) { - setModifiers(modifiers); - setId(id); - setElementType(elementType); + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + elementType, + new NodeList<>(), + false, + id); } public Parameter(final Range range, - EnumSet<Modifier> modifiers, - List<AnnotationExpr> annotations, + EnumSet<Modifier> modifiers, + NodeList<AnnotationExpr> annotations, Type elementType, - List<ArrayBracketPair> arrayBracketPairsAfterElementType, + NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType, boolean isVarArgs, VariableDeclaratorId id) { super(range); @@ -101,7 +124,7 @@ public final class Parameter extends Node implements setId(id); setElementType(elementType); setVarArgs(isVarArgs); - setArrayBracketPairsAfterElementType(arrayBracketPairsAfterElementType); + setArrayBracketPairsAfterElementType(assertNotNull(arrayBracketPairsAfterElementType)); } @Override @@ -115,7 +138,7 @@ public final class Parameter extends Node implements } @Override - public Type getType() { + public Type<?> getType() { return wrapInArrayTypes(elementType, getArrayBracketPairsAfterElementType(), getId().getArrayBracketPairsAfterId()); @@ -127,10 +150,10 @@ public final class Parameter extends Node implements @Override public Parameter setType(Type type) { - Pair<Type, List<ArrayBracketPair>> unwrapped = ArrayType.unwrapArrayTypes(type); + Pair<Type, NodeList<ArrayBracketPair>> unwrapped = ArrayType.unwrapArrayTypes(type); setElementType(unwrapped.a); setArrayBracketPairsAfterElementType(unwrapped.b); - getId().setArrayBracketPairsAfterId(null); + getId().setArrayBracketPairsAfterId(new NodeList<>()); return this; } @@ -142,8 +165,7 @@ public final class Parameter extends Node implements * @return the list returned could be immutable (in that case it will be empty) */ @Override - public List<AnnotationExpr> getAnnotations() { - annotations = ensureNotNull(annotations); + public NodeList<AnnotationExpr> getAnnotations() { return annotations; } @@ -159,6 +181,7 @@ public final class Parameter extends Node implements @SuppressWarnings("unchecked") @Override public Parameter setName(String name) { + assertNotNull(name); if (id != null) id.setName(name); else @@ -183,8 +206,8 @@ public final class Parameter extends Node implements */ @Override @SuppressWarnings("unchecked") - public Parameter setAnnotations(List<AnnotationExpr> annotations) { - this.annotations = annotations; + public Parameter setAnnotations(NodeList<AnnotationExpr> annotations) { + this.annotations = assertNotNull(annotations); setAsParentNodeOf(this.annotations); return this; } @@ -197,7 +220,7 @@ public final class Parameter extends Node implements @Override @SuppressWarnings("unchecked") public Parameter setModifiers(EnumSet<Modifier> modifiers) { - this.modifiers = modifiers; + this.modifiers = assertNotNull(modifiers); return this; } @@ -207,20 +230,19 @@ public final class Parameter extends Node implements } @Override - public Parameter setElementType(final Type elementType) { - this.elementType = elementType; + public Parameter setElementType(final Type<?> elementType) { + this.elementType = assertNotNull(elementType); setAsParentNodeOf(this.elementType); return this; } - public List<ArrayBracketPair> getArrayBracketPairsAfterElementType() { - arrayBracketPairsAfterType = ensureNotNull(arrayBracketPairsAfterType); + public NodeList<ArrayBracketPair> getArrayBracketPairsAfterElementType() { return arrayBracketPairsAfterType; } @Override - public Parameter setArrayBracketPairsAfterElementType(List<ArrayBracketPair> arrayBracketPairsAfterType) { - this.arrayBracketPairsAfterType = arrayBracketPairsAfterType; + public Parameter setArrayBracketPairsAfterElementType(NodeList<ArrayBracketPair> arrayBracketPairsAfterType) { + this.arrayBracketPairsAfterType = assertNotNull(arrayBracketPairsAfterType); setAsParentNodeOf(arrayBracketPairsAfterType); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/TypeDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/TypeDeclaration.java index 829d37c26..176b184ac 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/TypeDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/TypeDeclaration.java @@ -21,15 +21,9 @@ package com.github.javaparser.ast.body; -import static com.github.javaparser.utils.Utils.ensureNotNull; -import static com.github.javaparser.utils.Utils.isNullOrEmpty; - -import java.util.ArrayList; -import java.util.EnumSet; -import java.util.List; - import com.github.javaparser.Range; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.expr.NameExpr; @@ -38,6 +32,14 @@ import com.github.javaparser.ast.nodeTypes.NodeWithMembers; import com.github.javaparser.ast.nodeTypes.NodeWithModifiers; import com.github.javaparser.ast.nodeTypes.NodeWithName; +import java.util.EnumSet; +import java.util.Optional; + +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.ast.expr.NameExpr.*; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; + /** * @author Julio Vilmar Gesser */ @@ -48,56 +50,58 @@ public abstract class TypeDeclaration<T> extends BodyDeclaration<T> private EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); - private List<BodyDeclaration<?>> members; + private NodeList<BodyDeclaration<?>> members; public TypeDeclaration() { + this(Range.UNKNOWN, + new NodeList<>(), + EnumSet.noneOf(Modifier.class), + new NameExpr(), + new NodeList<>()); } public TypeDeclaration(EnumSet<Modifier> modifiers, String name) { - setName(name); - setModifiers(modifiers); + this(Range.UNKNOWN, + new NodeList<>(), + modifiers, + name(name), + new NodeList<>()); } - public TypeDeclaration(List<AnnotationExpr> annotations, - EnumSet<Modifier> modifiers, String name, - List<BodyDeclaration<?>> members) { - super(annotations); - setName(name); - setModifiers(modifiers); - setMembers(members); + public TypeDeclaration(NodeList<AnnotationExpr> annotations, + EnumSet<Modifier> modifiers, NameExpr name, + NodeList<BodyDeclaration<?>> members) { + this(Range.UNKNOWN, + annotations, + modifiers, + name, + members); } - public TypeDeclaration(Range range, List<AnnotationExpr> annotations, - EnumSet<Modifier> modifiers, String name, - List<BodyDeclaration<?>> members) { + public TypeDeclaration(Range range, NodeList<AnnotationExpr> annotations, + EnumSet<Modifier> modifiers, NameExpr name, + NodeList<BodyDeclaration<?>> members) { super(range, annotations); - setName(name); + setNameExpr(name); setModifiers(modifiers); setMembers(members); } /** - * Adds the given declaration to the specified type. The list of members - * will be initialized if it is <code>null</code>. + * Adds the given declaration to the specified type. * * @param decl * member declaration */ public TypeDeclaration<T> addMember(BodyDeclaration<?> decl) { - List<BodyDeclaration<?>> members = getMembers(); - if (isNullOrEmpty(members)) { - members = new ArrayList<>(); - setMembers(members); - } + NodeList<BodyDeclaration<?>> members = getMembers(); members.add(decl); - decl.setParentNode(this); return this; } - @Override - public List<BodyDeclaration<?>> getMembers() { - members = ensureNotNull(members); - return members; + @Override + public NodeList<BodyDeclaration<?>> getMembers() { + return members; } /** @@ -118,8 +122,8 @@ public abstract class TypeDeclaration<T> extends BodyDeclaration<T> @SuppressWarnings("unchecked") @Override - public T setMembers(List<BodyDeclaration<?>> members) { - this.members = members; + public T setMembers(NodeList<BodyDeclaration<?>> members) { + this.members = assertNotNull(members); setAsParentNodeOf(this.members); return (T) this; } @@ -127,21 +131,21 @@ public abstract class TypeDeclaration<T> extends BodyDeclaration<T> @SuppressWarnings("unchecked") @Override public T setModifiers(EnumSet<Modifier> modifiers) { - this.modifiers = modifiers; + this.modifiers = assertNotNull(modifiers); return (T) this; } @Override @SuppressWarnings("unchecked") public T setName(String name) { - setNameExpr(new NameExpr(name)); + setNameExpr(new NameExpr(assertNotNull(name))); return (T) this; } @SuppressWarnings("unchecked") public T setNameExpr(NameExpr nameExpr) { - this.name = nameExpr; - setAsParentNodeOf(this.name); + this.name = assertNotNull(nameExpr); + setAsParentNodeOf(name); return (T) this; } @@ -150,11 +154,13 @@ public abstract class TypeDeclaration<T> extends BodyDeclaration<T> } @Override - public JavadocComment getJavaDoc() { - if(getComment() instanceof JavadocComment){ - return (JavadocComment) getComment(); - } - return null; + public Optional<JavadocComment> getJavaDoc() { + if(getComment().isPresent()){ + if(getComment().get() instanceof JavadocComment){ + return (Optional<JavadocComment>) getComment(); + } + } + return none(); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclarator.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclarator.java index ff78d6e68..995f4fcd4 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclarator.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclarator.java @@ -24,6 +24,7 @@ package com.github.javaparser.ast.body; import com.github.javaparser.Range; import com.github.javaparser.ast.ArrayBracketPair; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.nodeTypes.NodeWithElementType; @@ -34,29 +35,33 @@ import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import com.github.javaparser.utils.Pair; -import java.util.List; +import java.util.Optional; import static com.github.javaparser.ast.type.ArrayType.wrapInArrayTypes; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; /** * @author Julio Vilmar Gesser */ public final class VariableDeclarator extends Node implements - NodeWithType<VariableDeclarator> { + NodeWithType<VariableDeclarator, Type<?>> { private VariableDeclaratorId id; - private Expression init; + private Optional<Expression> init; public VariableDeclarator() { + this(Range.UNKNOWN, new VariableDeclaratorId(), none()); } public VariableDeclarator(VariableDeclaratorId id) { - setId(id); + this(Range.UNKNOWN, id, none()); } public VariableDeclarator(String variableName) { - setId(new VariableDeclaratorId(variableName)); + this(Range.UNKNOWN, new VariableDeclaratorId(variableName), none()); } /** @@ -67,17 +72,15 @@ public final class VariableDeclarator extends Node implements * An {@link com.github.javaparser.ast.expr.AssignExpr} is unnecessary as the <code>=</code> operator is * already added. */ - public VariableDeclarator(VariableDeclaratorId id, Expression init) { - setId(id); - setInit(init); + public VariableDeclarator(VariableDeclaratorId id, Optional<Expression> init) { + this(Range.UNKNOWN, id, init); } - public VariableDeclarator(String variableName, Expression init) { - setId(new VariableDeclaratorId(variableName)); - setInit(init); + public VariableDeclarator(String variableName, Optional<Expression> init) { + this(Range.UNKNOWN, new VariableDeclaratorId(variableName), init); } - public VariableDeclarator(Range range, VariableDeclaratorId id, Expression init) { + public VariableDeclarator(Range range, VariableDeclaratorId id, Optional<Expression> init) { super(range); setId(id); setInit(init); @@ -97,18 +100,18 @@ public final class VariableDeclarator extends Node implements return id; } - public Expression getInit() { + public Optional<Expression> getInit() { return init; } public VariableDeclarator setId(VariableDeclaratorId id) { - this.id = id; + this.id = assertNotNull(id); setAsParentNodeOf(this.id); return this; } - public VariableDeclarator setInit(Expression init) { - this.init = init; + public VariableDeclarator setInit(Optional<Expression> init) { + this.init = assertNotNull(init); setAsParentNodeOf(this.init); return this; } @@ -117,7 +120,7 @@ public final class VariableDeclarator extends Node implements * Will create a {@link NameExpr} with the init param */ public VariableDeclarator setInit(String init) { - this.init = new NameExpr(init); + this.init = some(new NameExpr(assertNotNull(init))); setAsParentNodeOf(this.init); return this; } @@ -134,13 +137,13 @@ public final class VariableDeclarator extends Node implements @Override public VariableDeclarator setType(Type type) { - Pair<Type, List<ArrayBracketPair>> unwrapped = ArrayType.unwrapArrayTypes(type); + Pair<Type, NodeList<ArrayBracketPair>> unwrapped = ArrayType.unwrapArrayTypes(type); NodeWithElementType<?> nodeWithElementType = getParentNodeOfType(NodeWithElementType.class); if (nodeWithElementType == null) { throw new IllegalStateException("Cannot set type without a parent"); } nodeWithElementType.setElementType(unwrapped.a); - nodeWithElementType.setArrayBracketPairsAfterElementType(null); + nodeWithElementType.setArrayBracketPairsAfterElementType(new NodeList<>()); getId().setArrayBracketPairsAfterId(unwrapped.b); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclaratorId.java b/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclaratorId.java index b6dccc2aa..a9d37ca63 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclaratorId.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/body/VariableDeclaratorId.java @@ -24,13 +24,13 @@ package com.github.javaparser.ast.body; import com.github.javaparser.Range; import com.github.javaparser.ast.ArrayBracketPair; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithName; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.ast.NodeList.*; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * @author Julio Vilmar Gesser @@ -39,19 +39,24 @@ public final class VariableDeclaratorId extends Node implements NodeWithName<Var private String name; - private List<ArrayBracketPair> arrayBracketPairsAfterId; + private NodeList<ArrayBracketPair> arrayBracketPairsAfterId; public VariableDeclaratorId() { + this(Range.UNKNOWN, + "empty", + new NodeList<>()); } public VariableDeclaratorId(String name) { - setName(name); + this(Range.UNKNOWN, + name, + new NodeList<>()); } - public VariableDeclaratorId(Range range, String name, List<ArrayBracketPair> arrayBracketPairsAfterId) { + public VariableDeclaratorId(Range range, String name, NodeList<ArrayBracketPair> arrayBracketPairsAfterId) { super(range); setName(name); - setArrayBracketPairsAfterId(arrayBracketPairsAfterId); + setArrayBracketPairsAfterId(assertNotNull(arrayBracketPairsAfterId)); } @Override @@ -71,17 +76,16 @@ public final class VariableDeclaratorId extends Node implements NodeWithName<Var @Override public VariableDeclaratorId setName(String name) { - this.name = name; + this.name = assertNotNull(name); return this; } - public List<ArrayBracketPair> getArrayBracketPairsAfterId() { - arrayBracketPairsAfterId = ensureNotNull(arrayBracketPairsAfterId); + public NodeList<ArrayBracketPair> getArrayBracketPairsAfterId() { return arrayBracketPairsAfterId; } - public VariableDeclaratorId setArrayBracketPairsAfterId(List<ArrayBracketPair> arrayBracketPairsAfterId) { - this.arrayBracketPairsAfterId = arrayBracketPairsAfterId; + public VariableDeclaratorId setArrayBracketPairsAfterId(NodeList<ArrayBracketPair> arrayBracketPairsAfterId) { + this.arrayBracketPairsAfterId = assertNotNull(arrayBracketPairsAfterId); setAsParentNodeOf(arrayBracketPairsAfterId); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/BlockComment.java b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/BlockComment.java index 77157d595..210de95c9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/BlockComment.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/BlockComment.java @@ -37,10 +37,11 @@ import com.github.javaparser.ast.visitor.VoidVisitor; public final class BlockComment extends Comment { public BlockComment() { + this(Range.UNKNOWN, "empty"); } public BlockComment(String content) { - super(content); + this(Range.UNKNOWN, content); } public BlockComment(Range range, String content) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/Comment.java b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/Comment.java index 9da994ec4..363036944 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/Comment.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/Comment.java @@ -24,6 +24,11 @@ package com.github.javaparser.ast.comments; import com.github.javaparser.Range; import com.github.javaparser.ast.Node; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; + /** * Abstract class for all AST nodes that represent comments. * @@ -35,15 +40,8 @@ import com.github.javaparser.ast.Node; public abstract class Comment extends Node { private String content; - private Node commentedNode; - - public Comment() { - } - - public Comment(String content) { - this.content = content; - } - + private Optional<Node> commentedNode = none(); + public Comment(Range range, String content) { super(range); this.content = content; @@ -82,7 +80,7 @@ public abstract class Comment extends Node { } } - public Node getCommentedNode() + public Optional<Node> getCommentedNode() { return this.commentedNode; } @@ -90,7 +88,7 @@ public abstract class Comment extends Node { public Comment setCommentedNode(Node commentedNode) { if (commentedNode==null) { - this.commentedNode = null; + this.commentedNode = none(); return this; } if (commentedNode==this) { @@ -99,12 +97,12 @@ public abstract class Comment extends Node { if (commentedNode instanceof Comment) { throw new IllegalArgumentException(); } - this.commentedNode = commentedNode; + this.commentedNode = some(commentedNode); return this; } public boolean isOrphan() { - return this.commentedNode == null; + return !commentedNode.isPresent(); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/JavadocComment.java b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/JavadocComment.java index 18b77af28..709fabde5 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/JavadocComment.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/JavadocComment.java @@ -31,10 +31,11 @@ import com.github.javaparser.ast.visitor.VoidVisitor; public final class JavadocComment extends Comment { public JavadocComment() { + this(Range.UNKNOWN, "empty"); } public JavadocComment(String content) { - super(content); + this(Range.UNKNOWN, content); } public JavadocComment(Range range, String content) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/LineComment.java b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/LineComment.java index 56b8054d3..6c48d6ebd 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/comments/LineComment.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/comments/LineComment.java @@ -36,10 +36,11 @@ import com.github.javaparser.ast.visitor.VoidVisitor; public final class LineComment extends Comment { public LineComment() { + this(Range.UNKNOWN, "empty"); } public LineComment(String content) { - super(content); + this(Range.UNKNOWN, content); } public LineComment(Range range, String content) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AnnotationExpr.java index a1cad1cdb..aae1c65f8 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AnnotationExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AnnotationExpr.java @@ -23,6 +23,8 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -30,10 +32,9 @@ public abstract class AnnotationExpr extends Expression { protected NameExpr name; - public AnnotationExpr() {} - - public AnnotationExpr(Range range) { + public AnnotationExpr(Range range, NameExpr name) { super(range); + setName(name); } public NameExpr getName() { @@ -41,7 +42,7 @@ public abstract class AnnotationExpr extends Expression { } public AnnotationExpr setName(NameExpr name) { - this.name = name; + this.name = assertNotNull(name); setAsParentNodeOf(name); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayAccessExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayAccessExpr.java index b461ea87b..ba75050c2 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayAccessExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayAccessExpr.java @@ -25,6 +25,8 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -35,11 +37,11 @@ public final class ArrayAccessExpr extends Expression { private Expression index; public ArrayAccessExpr() { + this(Range.UNKNOWN, new NameExpr(), new IntegerLiteralExpr()); } public ArrayAccessExpr(Expression name, Expression index) { - setName(name); - setIndex(index); + this(Range.UNKNOWN, name, index); } public ArrayAccessExpr(Range range, Expression name, Expression index) { @@ -67,13 +69,13 @@ public final class ArrayAccessExpr extends Expression { } public ArrayAccessExpr setIndex(Expression index) { - this.index = index; + this.index = assertNotNull(index); setAsParentNodeOf(this.index); return this; } public ArrayAccessExpr setName(Expression name) { - this.name = name; + this.name = assertNotNull(name); setAsParentNodeOf(this.name); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayCreationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayCreationExpr.java index 79d55a56c..38b3e35f8 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayCreationExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayCreationExpr.java @@ -22,52 +22,68 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; -import com.github.javaparser.ast.nodeTypes.NodeWithType; import com.github.javaparser.ast.ArrayCreationLevel; +import com.github.javaparser.ast.CompilationUnit; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.type.ArrayType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** + * <code>new int[5][4][][]</code> or <code>new int[][]{{1},{2,3}}</code> + * * @author Julio Vilmar Gesser */ -public final class ArrayCreationExpr extends Expression implements NodeWithType<ArrayCreationExpr> { +// NOTE does not implement NodeWithType because setType is problematic +// NOTE does not implement NodeWithElementType because that implies a list of ArrayBracketPairs +public final class ArrayCreationExpr extends Expression { - private List<ArrayCreationLevel> levels; + private NodeList<ArrayCreationLevel> levels; - private Type type; + private Type<?> elementType; - private ArrayInitializerExpr initializer; + private Optional<ArrayInitializerExpr> initializer; public ArrayCreationExpr() { + this(Range.UNKNOWN, + new ClassOrInterfaceType(), + new NodeList<>(), + none()); } - public ArrayCreationExpr(Type type, List<ArrayCreationLevel> levels, ArrayInitializerExpr initializer) { - setLevels(levels); - setType(type); - setInitializer(initializer); + public ArrayCreationExpr(Type<?> elementType, NodeList<ArrayCreationLevel> levels, Optional<ArrayInitializerExpr> initializer) { + this(Range.UNKNOWN, + elementType, + levels, + initializer); } - public ArrayCreationExpr(Range range, Type type, List<ArrayCreationLevel> levels, ArrayInitializerExpr initializer) { - super(range); - setLevels(levels); - setType(type); - setInitializer(initializer); + public ArrayCreationExpr(Type<?> elementType) { + this(Range.UNKNOWN, + elementType, + new NodeList<>(), + none()); } - public ArrayCreationExpr(Type type) { - setType(type); - setInitializer(null); + public ArrayCreationExpr(Range range, Type<?> elementType) { + this(range, + elementType, + new NodeList<>(), + none()); } - public ArrayCreationExpr(Range range, Type type) { + public ArrayCreationExpr(Range range, Type<?> elementType, NodeList<ArrayCreationLevel> levels, Optional<ArrayInitializerExpr> initializer) { super(range); - setType(type); - setInitializer(null); + setLevels(levels); + setElementType(elementType); + setInitializer(initializer); } @Override @@ -80,36 +96,60 @@ public final class ArrayCreationExpr extends Expression implements NodeWithType< v.visit(this, arg); } - public ArrayInitializerExpr getInitializer() { + public Optional<ArrayInitializerExpr> getInitializer() { return initializer; } - @Override - public Type getType() { - return type; + public Type<?> getElementType() { + return elementType; } - public ArrayCreationExpr setInitializer(ArrayInitializerExpr initializer) { - this.initializer = initializer; + public ArrayCreationExpr setInitializer(Optional<ArrayInitializerExpr> initializer) { + this.initializer = assertNotNull(initializer); setAsParentNodeOf(this.initializer); return this; } - @Override - public ArrayCreationExpr setType(Type type) { - this.type = type; - setAsParentNodeOf(this.type); + public ArrayCreationExpr setElementType(Type<?> elementType) { + this.elementType = assertNotNull(elementType); + setAsParentNodeOf(this.elementType); return this; } - public List<ArrayCreationLevel> getLevels() { - levels = ensureNotNull(levels); + public NodeList<ArrayCreationLevel> getLevels() { return levels; } - public ArrayCreationExpr setLevels(List<ArrayCreationLevel> levels) { - this.levels = levels; + public ArrayCreationExpr setLevels(NodeList<ArrayCreationLevel> levels) { + this.levels = assertNotNull(levels); setAsParentNodeOf(levels); return this; } + + /** + * Takes the element type and wraps it in an ArrayType for every array creation level. + */ + public Type<?> getType() { + Type<?> result = elementType; + for (int i = 0; i < levels.size(); i++) { + result = new ArrayType(result, new NodeList<>()); + } + return result; + } + + /** + * Sets this type to this class and try to import it to the {@link CompilationUnit} if needed + * + * @param typeClass the type + * @return this + */ + public ArrayCreationExpr setElementType(Class<?> typeClass) { + tryAddImportToParentCompilationUnit(typeClass); + return setElementType(new ClassOrInterfaceType(typeClass.getSimpleName())); + } + + public ArrayCreationExpr setElementType(final String type) { + ClassOrInterfaceType classOrInterfaceType = new ClassOrInterfaceType(type); + return setElementType(classOrInterfaceType); + } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayInitializerExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayInitializerExpr.java index 67c10739b..8782a0da1 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayInitializerExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ArrayInitializerExpr.java @@ -22,28 +22,28 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * @author Julio Vilmar Gesser */ public final class ArrayInitializerExpr extends Expression { - private List<Expression> values; + private NodeList<Expression> values; public ArrayInitializerExpr() { + this(Range.UNKNOWN, new NodeList<>()); } - public ArrayInitializerExpr(List<Expression> values) { - setValues(values); + public ArrayInitializerExpr(NodeList<Expression> values) { + this(Range.UNKNOWN, values); } - public ArrayInitializerExpr(Range range, List<Expression> values) { + public ArrayInitializerExpr(Range range, NodeList<Expression> values) { super(range); setValues(values); } @@ -58,13 +58,12 @@ public final class ArrayInitializerExpr extends Expression { v.visit(this, arg); } - public List<Expression> getValues() { - values = ensureNotNull(values); + public NodeList<Expression> getValues() { return values; } - public ArrayInitializerExpr setValues(List<Expression> values) { - this.values = values; + public ArrayInitializerExpr setValues(NodeList<Expression> values) { + this.values = assertNotNull(values); setAsParentNodeOf(this.values); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AssignExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AssignExpr.java index cf16c6fff..e3832224d 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AssignExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/AssignExpr.java @@ -52,12 +52,11 @@ public final class AssignExpr extends Expression { private Operator op; public AssignExpr() { + this(Range.UNKNOWN, new NameExpr(), new StringLiteralExpr(), Operator.assign); } public AssignExpr(Expression target, Expression value, Operator op) { - setTarget(target); - setValue(value); - setOperator(op); + this(Range.UNKNOWN, target, value, op); } public AssignExpr(Range range, Expression target, Expression value, Operator op) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BinaryExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BinaryExpr.java index 83675c8c4..f0785f859 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BinaryExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BinaryExpr.java @@ -59,12 +59,11 @@ public final class BinaryExpr extends Expression { private Operator op; public BinaryExpr() { + this(Range.UNKNOWN, new BooleanLiteralExpr(), new BooleanLiteralExpr(), Operator.equals); } public BinaryExpr(Expression left, Expression right, Operator op) { - setLeft(left); - setRight(right); - setOperator(op); + this(Range.UNKNOWN, left, right, op); } public BinaryExpr(Range range, Expression left, Expression right, Operator op) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BooleanLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BooleanLiteralExpr.java index a42c8c722..f1c318842 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BooleanLiteralExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/BooleanLiteralExpr.java @@ -33,10 +33,11 @@ public final class BooleanLiteralExpr extends LiteralExpr { private boolean value; public BooleanLiteralExpr() { + this(Range.UNKNOWN, false); } public BooleanLiteralExpr(boolean value) { - setValue(value); + this(Range.UNKNOWN, value); } public BooleanLiteralExpr(Range range, boolean value) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CastExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CastExpr.java index d2a54bc08..78fcbbe0f 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CastExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/CastExpr.java @@ -23,28 +23,31 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ -public final class CastExpr extends Expression implements NodeWithType<CastExpr> { +public final class CastExpr extends Expression implements NodeWithType<CastExpr, Type<?>> { - private Type type; + private Type<?> type; private Expression expr; public CastExpr() { + this(Range.UNKNOWN, new ClassOrInterfaceType(), new NameExpr()); } - public CastExpr(Type type, Expression expr) { - setType(type); - setExpr(expr); + public CastExpr(Type<?> type, Expression expr) { + this(Range.UNKNOWN, type, expr); } - public CastExpr(Range range, Type type, Expression expr) { + public CastExpr(Range range, Type<?> type, Expression expr) { super(range); setType(type); setExpr(expr); @@ -65,19 +68,19 @@ public final class CastExpr extends Expression implements NodeWithType<CastExpr> } @Override - public Type getType() { + public Type<?> getType() { return type; } public CastExpr setExpr(Expression expr) { - this.expr = expr; + this.expr = assertNotNull(expr); setAsParentNodeOf(this.expr); return this; } @Override - public CastExpr setType(Type type) { - this.type = type; + public CastExpr setType(Type<?> type) { + this.type = assertNotNull(type); setAsParentNodeOf(this.type); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ClassExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ClassExpr.java index a6dc9058d..576c2dedd 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ClassExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ClassExpr.java @@ -23,6 +23,7 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; @@ -35,15 +36,16 @@ import com.github.javaparser.ast.visitor.VoidVisitor; * </code> * @author Julio Vilmar Gesser */ -public final class ClassExpr extends Expression implements NodeWithType<ClassExpr> { +public final class ClassExpr extends Expression implements NodeWithType<ClassExpr, Type<?>> { private Type type; public ClassExpr() { + this(Range.UNKNOWN, new ClassOrInterfaceType()); } - public ClassExpr(Type type) { - setType(type); + public ClassExpr(Type<?> type) { + this(Range.UNKNOWN, type); } public ClassExpr(Range range, Type type) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ConditionalExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ConditionalExpr.java index 4dd4c4b0f..2778d7536 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ConditionalExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ConditionalExpr.java @@ -25,6 +25,8 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -37,12 +39,11 @@ public final class ConditionalExpr extends Expression { private Expression elseExpr; public ConditionalExpr() { + this(Range.UNKNOWN, new BooleanLiteralExpr(), new StringLiteralExpr(), new StringLiteralExpr()); } public ConditionalExpr(Expression condition, Expression thenExpr, Expression elseExpr) { - setCondition(condition); - setThenExpr(thenExpr); - setElseExpr(elseExpr); + this(Range.UNKNOWN, condition, thenExpr, elseExpr); } public ConditionalExpr(Range range, Expression condition, Expression thenExpr, Expression elseExpr) { @@ -75,19 +76,19 @@ public final class ConditionalExpr extends Expression { } public ConditionalExpr setCondition(Expression condition) { - this.condition = condition; + this.condition = assertNotNull(condition); setAsParentNodeOf(this.condition); return this; } public ConditionalExpr setElseExpr(Expression elseExpr) { - this.elseExpr = elseExpr; + this.elseExpr = assertNotNull(elseExpr); setAsParentNodeOf(this.elseExpr); return this; } public ConditionalExpr setThenExpr(Expression thenExpr) { - this.thenExpr = thenExpr; + this.thenExpr = assertNotNull(thenExpr); setAsParentNodeOf(this.thenExpr); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/EnclosedExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/EnclosedExpr.java index a7c40febc..2cf1e5ed8 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/EnclosedExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/EnclosedExpr.java @@ -25,21 +25,27 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; + /** * @author Julio Vilmar Gesser */ public final class EnclosedExpr extends Expression { - private Expression inner; + private Optional<Expression> inner; public EnclosedExpr() { + this(Range.UNKNOWN, none()); } - public EnclosedExpr(final Expression inner) { - setInner(inner); + public EnclosedExpr(final Optional<Expression> inner) { + this(Range.UNKNOWN, inner); } - public EnclosedExpr(final Range range, final Expression inner) { + public EnclosedExpr(final Range range, final Optional<Expression> inner) { super(range); setInner(inner); } @@ -52,12 +58,12 @@ public final class EnclosedExpr extends Expression { v.visit(this, arg); } - public Expression getInner() { + public Optional<Expression> getInner() { return inner; } - public EnclosedExpr setInner(final Expression inner) { - this.inner = inner; + public EnclosedExpr setInner(final Optional<Expression> inner) { + this.inner = assertNotNull(inner); setAsParentNodeOf(this.inner); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java index f9745646f..310632938 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/Expression.java @@ -28,12 +28,7 @@ import com.github.javaparser.ast.Node; * @author Julio Vilmar Gesser */ public abstract class Expression extends Node { - - public Expression() { - } - - public Expression(Range range) { + public Expression(Range range) { super(range); } - } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/FieldAccessExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/FieldAccessExpr.java index 0a4badf5c..ef94179be 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/FieldAccessExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/FieldAccessExpr.java @@ -22,12 +22,17 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; + +import static com.github.javaparser.ast.expr.NameExpr.name; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser @@ -36,23 +41,23 @@ public final class FieldAccessExpr extends Expression implements NodeWithTypeArg private Expression scope; - private List<Type<?>> typeArguments; + private Optional<NodeList<Type<?>>> typeArguments; private NameExpr field; public FieldAccessExpr() { + this(Range.UNKNOWN, new ThisExpr(), none(), new NameExpr()); } public FieldAccessExpr(final Expression scope, final String field) { - setScope(scope); - setField(field); + this(Range.UNKNOWN, scope, none(), name(field)); } - public FieldAccessExpr(final Range range, final Expression scope, final List<Type<?>> typeArguments, final String field) { + public FieldAccessExpr(final Range range, final Expression scope, final Optional<NodeList<Type<?>>> typeArguments, final NameExpr field) { super(range); setScope(scope); setTypeArguments(typeArguments); - setField(field); + setFieldExpr(field); } @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { @@ -81,26 +86,25 @@ public final class FieldAccessExpr extends Expression implements NodeWithTypeArg } public FieldAccessExpr setFieldExpr(NameExpr field) { - this.field = field; + this.field = assertNotNull(field); setAsParentNodeOf(this.field); return this; } public FieldAccessExpr setScope(final Expression scope) { - this.scope = scope; + this.scope = assertNotNull(scope); setAsParentNodeOf(this.scope); return this; } - - + @Override - public List<Type<?>> getTypeArguments() { + public Optional<NodeList<Type<?>>> getTypeArguments() { return typeArguments; } @Override - public FieldAccessExpr setTypeArguments(final List<Type<?>> types) { - this.typeArguments = types; + public FieldAccessExpr setTypeArguments(final Optional<NodeList<Type<?>>> types) { + this.typeArguments = assertNotNull(types); setAsParentNodeOf(this.typeArguments); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/InstanceOfExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/InstanceOfExpr.java index ffc248ce6..d7cb9f2d3 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/InstanceOfExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/InstanceOfExpr.java @@ -23,28 +23,32 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.ReferenceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ -public final class InstanceOfExpr extends Expression implements NodeWithType<InstanceOfExpr> { +public final class InstanceOfExpr extends Expression implements NodeWithType<InstanceOfExpr, ReferenceType<?>> { private Expression expr; - private Type type; + private ReferenceType<?> type; public InstanceOfExpr() { + this(Range.UNKNOWN, new NameExpr(), new ClassOrInterfaceType()); } - public InstanceOfExpr(final Expression expr, final Type type) { - setExpr(expr); - setType(type); + public InstanceOfExpr(final Expression expr, final ReferenceType<?> type) { + this(Range.UNKNOWN, expr, type); } - public InstanceOfExpr(final Range range, final Expression expr, final Type type) { + public InstanceOfExpr(final Range range, final Expression expr, final ReferenceType<?> type) { super(range); setExpr(expr); setType(type); @@ -63,19 +67,19 @@ public final class InstanceOfExpr extends Expression implements NodeWithType<Ins } @Override - public Type getType() { + public ReferenceType<?> getType() { return type; } public InstanceOfExpr setExpr(final Expression expr) { - this.expr = expr; + this.expr = assertNotNull(expr); setAsParentNodeOf(this.expr); return this; } @Override - public InstanceOfExpr setType(final Type type) { - this.type = type; + public InstanceOfExpr setType(final ReferenceType<?> type) { + this.type = assertNotNull(type); setAsParentNodeOf(this.type); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/IntegerLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/IntegerLiteralExpr.java index 91f5dec77..1bfe5667a 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/IntegerLiteralExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/IntegerLiteralExpr.java @@ -35,10 +35,11 @@ public class IntegerLiteralExpr extends StringLiteralExpr { protected static final String MIN_VALUE = "-" + UNSIGNED_MIN_VALUE; public IntegerLiteralExpr() { + this(Range.UNKNOWN, "0"); } public IntegerLiteralExpr(final String value) { - super(value); + this(Range.UNKNOWN, value); } public IntegerLiteralExpr(final Range range, final String value) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java index 4db1b0dfb..faa6ca201 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LambdaExpr.java @@ -22,7 +22,10 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.body.Parameter; +import com.github.javaparser.ast.nodeTypes.NodeWithParameters; +import com.github.javaparser.ast.stmt.EmptyStmt; import com.github.javaparser.ast.stmt.Statement; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; @@ -36,18 +39,23 @@ import static com.github.javaparser.utils.Utils.*; * * @author Raquel Pau */ -public class LambdaExpr extends Expression { +public class LambdaExpr extends Expression implements + NodeWithParameters<LambdaExpr> { - private List<Parameter> parameters; + private NodeList<Parameter> parameters; private boolean parametersEnclosed; private Statement body; public LambdaExpr() { + this(Range.UNKNOWN, + new NodeList<>(), + new EmptyStmt(), + false); } - public LambdaExpr(Range range, List<Parameter> parameters, Statement body, + public LambdaExpr(Range range, NodeList<Parameter> parameters, Statement body, boolean parametersEnclosed) { super(range); @@ -56,13 +64,14 @@ public class LambdaExpr extends Expression { setParametersEnclosed(parametersEnclosed); } - public List<Parameter> getParameters() { - parameters = ensureNotNull(parameters); + @Override + public NodeList<Parameter> getParameters() { return parameters; } - public LambdaExpr setParameters(List<Parameter> parameters) { - this.parameters = parameters; + @Override + public LambdaExpr setParameters(NodeList<Parameter> parameters) { + this.parameters = assertNotNull(parameters); setAsParentNodeOf(this.parameters); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralExpr.java index 9cafefdc4..4bd8a3f55 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/LiteralExpr.java @@ -27,11 +27,7 @@ import com.github.javaparser.Range; * @author Julio Vilmar Gesser */ public abstract class LiteralExpr extends Expression { - - public LiteralExpr() { - } - - public LiteralExpr(Range range) { + public LiteralExpr(Range range) { super(range); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MarkerAnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MarkerAnnotationExpr.java index 1a117ff97..7ba85ef06 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MarkerAnnotationExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MarkerAnnotationExpr.java @@ -31,15 +31,16 @@ import com.github.javaparser.ast.visitor.VoidVisitor; public final class MarkerAnnotationExpr extends AnnotationExpr { public MarkerAnnotationExpr() { + this(Range.UNKNOWN, new NameExpr()); + } public MarkerAnnotationExpr(final NameExpr name) { - setName(name); + this(Range.UNKNOWN, name); } public MarkerAnnotationExpr(final Range range, final NameExpr name) { - super(range); - setName(name); + super(range, name); } @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MemberValuePair.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MemberValuePair.java index f87af5dbb..5b74a8063 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MemberValuePair.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MemberValuePair.java @@ -27,6 +27,8 @@ import com.github.javaparser.ast.nodeTypes.NodeWithName; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -37,11 +39,11 @@ public final class MemberValuePair extends Node implements NodeWithName<MemberVa private Expression value; public MemberValuePair() { + this(Range.UNKNOWN, "empty", new StringLiteralExpr()); } public MemberValuePair(final String name, final Expression value) { - setName(name); - setValue(value); + this(Range.UNKNOWN, name, value); } public MemberValuePair(final Range range, final String name, final Expression value) { @@ -69,12 +71,12 @@ public final class MemberValuePair extends Node implements NodeWithName<MemberVa @Override public MemberValuePair setName(final String name) { - this.name = name; + this.name = assertNotNull(name); return this; } public MemberValuePair setValue(final Expression value) { - this.value = value; + this.value = assertNotNull(value); setAsParentNodeOf(this.value); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodCallExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodCallExpr.java index 98a246455..311c71c1b 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodCallExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodCallExpr.java @@ -22,66 +22,66 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.nodeTypes.NodeWithArguments; import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.ast.expr.NameExpr.*; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser */ -public final class MethodCallExpr extends Expression implements NodeWithTypeArguments<MethodCallExpr> { +public final class MethodCallExpr extends Expression implements + NodeWithTypeArguments<MethodCallExpr>, + NodeWithArguments<MethodCallExpr> { - private Expression scope; + private Optional<Expression> scope; - private List<Type<?>> typeArguments; + private Optional<NodeList<Type<?>>> typeArguments; private NameExpr name; - private List<Expression> args; + private NodeList<Expression> args; public MethodCallExpr() { + this(Range.UNKNOWN, + none(), + none(), + new NameExpr(), + new NodeList<>()); } - public MethodCallExpr(final Expression scope, final String name) { - setScope(scope); - setName(name); + public MethodCallExpr(final Optional<Expression> scope, final String name) { + this(Range.UNKNOWN, + scope, + none(), + name(name), + new NodeList<>()); } - public MethodCallExpr(final Expression scope, final String name, final List<Expression> args) { - setScope(scope); - setName(name); - setArgs(args); + public MethodCallExpr(final Optional<Expression> scope, final NameExpr name, final NodeList<Expression> args) { + this(Range.UNKNOWN, + scope, + none(), + name, + args); } - public MethodCallExpr(final Range range, final Expression scope, final List<Type<?>> typeArguments, final String name, final List<Expression> args) { + public MethodCallExpr(final Range range, final Optional<Expression> scope, final Optional<NodeList<Type<?>>> typeArguments, final NameExpr name, final NodeList<Expression> args) { super(range); setScope(scope); setTypeArguments(typeArguments); - setName(name); + setNameExpr(name); setArgs(args); } - /** - * Adds the given argument to the method call. - * - * @param arg - * argument value - */ - public MethodCallExpr addArgument(Expression arg) { - getArgs().add(arg); - arg.setParentNode(this); - return this; - } - - public void addArgument(String arg) { - addArgument(new NameExpr(arg)); - } - @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { return v.visit(this, arg); @@ -92,8 +92,8 @@ public final class MethodCallExpr extends Expression implements NodeWithTypeArgu v.visit(this, arg); } - public List<Expression> getArgs() { - args = ensureNotNull(args); + @Override + public NodeList<Expression> getArgs() { return args; } @@ -105,40 +105,42 @@ public final class MethodCallExpr extends Expression implements NodeWithTypeArgu return name; } - public Expression getScope() { + public Optional<Expression> getScope() { return scope; } - public void setArgs(final List<Expression> args) { - this.args = args; + @Override + public MethodCallExpr setArgs(final NodeList<Expression> args) { + this.args = assertNotNull(args); setAsParentNodeOf(this.args); + return this; } public MethodCallExpr setName(final String name) { - setNameExpr(new NameExpr(name)); + setNameExpr(new NameExpr(assertNotNull(name))); return this; } public MethodCallExpr setNameExpr(NameExpr name) { - this.name = name; + this.name = assertNotNull(name); setAsParentNodeOf(this.name); return this; } - public MethodCallExpr setScope(final Expression scope) { - this.scope = scope; + public MethodCallExpr setScope(final Optional<Expression> scope) { + this.scope = assertNotNull(scope); setAsParentNodeOf(this.scope); return this; } @Override - public List<Type<?>> getTypeArguments() { + public Optional<NodeList<Type<?>>> getTypeArguments() { return typeArguments; } @Override - public MethodCallExpr setTypeArguments(final List<Type<?>> types) { - this.typeArguments = types; + public MethodCallExpr setTypeArguments(final Optional<NodeList<Type<?>>> types) { + this.typeArguments = assertNotNull(types); setAsParentNodeOf(this.typeArguments); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodReferenceExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodReferenceExpr.java index d048ca16a..a5699ff7b 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodReferenceExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/MethodReferenceExpr.java @@ -22,14 +22,16 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * Method reference expressions introduced in Java 8 specifically designed to simplify lambda Expressions. @@ -45,15 +47,19 @@ public class MethodReferenceExpr extends Expression implements NodeWithTypeArgum private Expression scope; - private List<Type<?>> typeArguments; + private Optional<NodeList<Type<?>>> typeArguments; private String identifier; public MethodReferenceExpr() { + this(Range.UNKNOWN, + new ClassExpr(), + none(), + "empty"); } public MethodReferenceExpr(Range range, Expression scope, - List<Type<?>> typeArguments, String identifier) { + Optional<NodeList<Type<?>>> typeArguments, String identifier) { super(range); setIdentifier(identifier); setScope(scope); @@ -76,19 +82,19 @@ public class MethodReferenceExpr extends Expression implements NodeWithTypeArgum } public MethodReferenceExpr setScope(Expression scope) { - this.scope = scope; + this.scope = assertNotNull(scope); setAsParentNodeOf(this.scope); return this; } @Override - public List<Type<?>> getTypeArguments() { + public Optional<NodeList<Type<?>>> getTypeArguments() { return typeArguments; } @Override - public MethodReferenceExpr setTypeArguments(final List<Type<?>> types) { - this.typeArguments = types; + public MethodReferenceExpr setTypeArguments(final Optional<NodeList<Type<?>>> types) { + this.typeArguments = assertNotNull(types); setAsParentNodeOf(this.typeArguments); return this; } @@ -98,7 +104,7 @@ public class MethodReferenceExpr extends Expression implements NodeWithTypeArgum } public MethodReferenceExpr setIdentifier(String identifier) { - this.identifier = identifier; + this.identifier = assertNotNull(identifier); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NameExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NameExpr.java index 944f70ff2..d55635d69 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NameExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NameExpr.java @@ -26,6 +26,8 @@ import com.github.javaparser.ast.nodeTypes.NodeWithName; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -34,15 +36,16 @@ public class NameExpr extends Expression implements NodeWithName<NameExpr> { private String name; public NameExpr() { + this(Range.UNKNOWN, "empty"); } public NameExpr(final String name) { - this.name = name; + this(Range.UNKNOWN, name); } public NameExpr(Range range, final String name) { super(range); - this.name = name; + setName(name); } @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { @@ -60,7 +63,7 @@ public class NameExpr extends Expression implements NodeWithName<NameExpr> { @Override public NameExpr setName(final String name) { - this.name = name; + this.name = assertNotNull(name); return this; } @@ -73,6 +76,7 @@ public class NameExpr extends Expression implements NodeWithName<NameExpr> { * qualified name * @return instanceof {@link NameExpr} */ + // TODO this needs a more specific name, like "parse" public static NameExpr name(String qualifiedName) { String[] split = qualifiedName.split("\\."); NameExpr ret = new NameExpr(split[0]); diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NormalAnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NormalAnnotationExpr.java index 502b11dbd..a58ee668e 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NormalAnnotationExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NormalAnnotationExpr.java @@ -22,36 +22,30 @@ package com.github.javaparser.ast.expr; import static com.github.javaparser.ast.expr.NameExpr.*; -import static com.github.javaparser.utils.Utils.ensureNotNull; - -import java.util.List; +import static com.github.javaparser.utils.Utils.assertNotNull; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - -import static com.github.javaparser.utils.Utils.ensureNotNull; - /** * @author Julio Vilmar Gesser */ public final class NormalAnnotationExpr extends AnnotationExpr { - private List<MemberValuePair> pairs; + private NodeList<MemberValuePair> pairs; public NormalAnnotationExpr() { + this(Range.UNKNOWN, name("empty"), new NodeList<>()); } - public NormalAnnotationExpr(final NameExpr name, final List<MemberValuePair> pairs) { - setName(name); - setPairs(pairs); + public NormalAnnotationExpr(final NameExpr name, final NodeList<MemberValuePair> pairs) { + this(Range.UNKNOWN, name, pairs); } - public NormalAnnotationExpr(final Range range, final NameExpr name, final List<MemberValuePair> pairs) { - super(range); - setName(name); + public NormalAnnotationExpr(final Range range, final NameExpr name, final NodeList<MemberValuePair> pairs) { + super(range, name); setPairs(pairs); } @@ -65,13 +59,12 @@ public final class NormalAnnotationExpr extends AnnotationExpr { v.visit(this, arg); } - public List<MemberValuePair> getPairs() { - pairs = ensureNotNull(pairs); + public NodeList<MemberValuePair> getPairs() { return pairs; } - public NormalAnnotationExpr setPairs(final List<MemberValuePair> pairs) { - this.pairs = pairs; + public NormalAnnotationExpr setPairs(final NodeList<MemberValuePair> pairs) { + this.pairs = assertNotNull(pairs); setAsParentNodeOf(this.pairs); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NullLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NullLiteralExpr.java index cb0a92b83..f6c492516 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NullLiteralExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/NullLiteralExpr.java @@ -31,6 +31,7 @@ import com.github.javaparser.ast.visitor.VoidVisitor; public final class NullLiteralExpr extends LiteralExpr { public NullLiteralExpr() { + this(Range.UNKNOWN); } public NullLiteralExpr(final Range range) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ObjectCreationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ObjectCreationExpr.java index 4d06ff8db..5e09d3dbe 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ObjectCreationExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ObjectCreationExpr.java @@ -22,7 +22,9 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.body.BodyDeclaration; +import com.github.javaparser.ast.nodeTypes.NodeWithArguments; import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; import com.github.javaparser.ast.nodeTypes.NodeWithType; import com.github.javaparser.ast.type.ClassOrInterfaceType; @@ -30,10 +32,11 @@ import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.ArrayList; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; /** * Defines constructor call expression. @@ -46,20 +49,26 @@ import static com.github.javaparser.utils.Utils.ensureNotNull; */ public final class ObjectCreationExpr extends Expression implements NodeWithTypeArguments<ObjectCreationExpr>, - NodeWithType<ObjectCreationExpr> { + NodeWithType<ObjectCreationExpr, ClassOrInterfaceType>, + NodeWithArguments<ObjectCreationExpr> { - private Expression scope; + private Optional<Expression> scope; private ClassOrInterfaceType type; - private List<Type<?>> typeArguments; + private Optional<NodeList<Type<?>>> typeArguments; - private List<Expression> args; + private NodeList<Expression> args; - // This can be null, to indicate there is no body - private List<BodyDeclaration<?>> anonymousClassBody; + private Optional<NodeList<BodyDeclaration<?>>> anonymousClassBody = null; public ObjectCreationExpr() { + this(Range.UNKNOWN, + none(), + new ClassOrInterfaceType(), + none(), + new NodeList<>(), + none()); } /** @@ -69,15 +78,18 @@ public final class ObjectCreationExpr extends Expression implements * @param type this is the class that the constructor is being called for. * @param args Any arguments to pass to the constructor */ - public ObjectCreationExpr(final Expression scope, final ClassOrInterfaceType type, final List<Expression> args) { - setScope(scope); - setType(type); - setArgs(args); + public ObjectCreationExpr(final Optional<Expression> scope, final ClassOrInterfaceType type, final NodeList<Expression> args) { + this(Range.UNKNOWN, + scope, + type, + none(), + args, + none()); } public ObjectCreationExpr(final Range range, - final Expression scope, final ClassOrInterfaceType type, final List<Type<?>> typeArguments, - final List<Expression> args, final List<BodyDeclaration<?>> anonymousBody) { + final Optional<Expression> scope, final ClassOrInterfaceType type, final Optional<NodeList<Type<?>>> typeArguments, + final NodeList<Expression> args, final Optional<NodeList<BodyDeclaration<?>>> anonymousBody) { super(range); setScope(scope); setType(type); @@ -99,23 +111,22 @@ public final class ObjectCreationExpr extends Expression implements /** * This can be null, to indicate there is no body */ - public List<BodyDeclaration<?>> getAnonymousClassBody() { + public Optional<NodeList<BodyDeclaration<?>>> getAnonymousClassBody() { return anonymousClassBody; } public void addAnonymousClassBody(BodyDeclaration<?> body) { - if (anonymousClassBody == null) - anonymousClassBody = new ArrayList<>(); - anonymousClassBody.add(body); - body.setParentNode(this); + if(!anonymousClassBody.isPresent()){ + anonymousClassBody = some(new NodeList<>()); + } + anonymousClassBody.get().add(body); } - public List<Expression> getArgs() { - args = ensureNotNull(args); + public NodeList<Expression> getArgs() { return args; } - public Expression getScope() { + public Optional<Expression> getScope() { return scope; } @@ -124,41 +135,41 @@ public final class ObjectCreationExpr extends Expression implements return type; } - public ObjectCreationExpr setAnonymousClassBody(final List<BodyDeclaration<?>> anonymousClassBody) { - this.anonymousClassBody = anonymousClassBody; + public ObjectCreationExpr setAnonymousClassBody(final Optional<NodeList<BodyDeclaration<?>>> anonymousClassBody) { + this.anonymousClassBody = assertNotNull(anonymousClassBody); setAsParentNodeOf(this.anonymousClassBody); return this; } - public ObjectCreationExpr setArgs(final List<Expression> args) { - this.args = args; + @Override + public ObjectCreationExpr setArgs(final NodeList<Expression> args) { + this.args = assertNotNull(args); setAsParentNodeOf(this.args); return this; } - public ObjectCreationExpr setScope(final Expression scope) { - this.scope = scope; + public ObjectCreationExpr setScope(final Optional<Expression> scope) { + this.scope = assertNotNull(scope); setAsParentNodeOf(this.scope); return this; } @Override - public ObjectCreationExpr setType(final Type<?> type) { - if (!(type instanceof ClassOrInterfaceType))// needed so we can use NodeWithType - throw new RuntimeException("You can only add ClassOrInterfaceType to an ObjectCreationExpr"); - this.type = (ClassOrInterfaceType) type; + public ObjectCreationExpr setType(final ClassOrInterfaceType type) { + assertNotNull(type); + this.type = type; setAsParentNodeOf(this.type); return this; } @Override - public List<Type<?>> getTypeArguments() { + public Optional<NodeList<Type<?>>> getTypeArguments() { return typeArguments; } @Override - public ObjectCreationExpr setTypeArguments(final List<Type<?>> types) { - this.typeArguments = types; + public ObjectCreationExpr setTypeArguments(final Optional<NodeList<Type<?>>> typeArguments) { + this.typeArguments = assertNotNull(typeArguments); setAsParentNodeOf(this.typeArguments); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SingleMemberAnnotationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SingleMemberAnnotationExpr.java index bd6692c83..8cfd607e0 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SingleMemberAnnotationExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SingleMemberAnnotationExpr.java @@ -33,16 +33,15 @@ public final class SingleMemberAnnotationExpr extends AnnotationExpr { private Expression memberValue; public SingleMemberAnnotationExpr() { + this(Range.UNKNOWN, new NameExpr(), new StringLiteralExpr()); } public SingleMemberAnnotationExpr(final NameExpr name, final Expression memberValue) { - setName(name); - setMemberValue(memberValue); + this(Range.UNKNOWN, name, memberValue); } public SingleMemberAnnotationExpr(final Range range, final NameExpr name, final Expression memberValue) { - super(range); - setName(name); + super(range, name); setMemberValue(memberValue); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/StringLiteralExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/StringLiteralExpr.java index f66a594da..737d413e9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/StringLiteralExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/StringLiteralExpr.java @@ -22,9 +22,11 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; -import com.github.javaparser.utils.Utils; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import com.github.javaparser.utils.Utils; + +import static com.github.javaparser.utils.Utils.assertNotNull; /** * Java® Language Specification 3.10.5 String Literals @@ -35,14 +37,11 @@ public class StringLiteralExpr extends LiteralExpr { protected String value; public StringLiteralExpr() { - this.value = ""; + this(Range.UNKNOWN, "empty"); } public StringLiteralExpr(final String value) { - if (value.contains("\n") || value.contains("\r")) { - throw new IllegalArgumentException("Illegal literal expression: newlines (line feed or carriage return) have to be escaped"); - } - this.value = value; + this(Range.UNKNOWN, value); } /** @@ -54,7 +53,10 @@ public class StringLiteralExpr extends LiteralExpr { public StringLiteralExpr(final Range range, final String value) { super(range); - this.value = value; + if (value.contains("\n") || value.contains("\r")) { + throw new IllegalArgumentException("Illegal literal expression: newlines (line feed or carriage return) have to be escaped"); + } + setValue(value); } @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { @@ -70,7 +72,7 @@ public class StringLiteralExpr extends LiteralExpr { } public final StringLiteralExpr setValue(final String value) { - this.value = value; - return this; + this.value = assertNotNull(value); + return this; } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SuperExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SuperExpr.java index 3f5e1866c..54408580e 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SuperExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/SuperExpr.java @@ -25,21 +25,26 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ public final class SuperExpr extends Expression { - private Expression classExpr; + private Optional<Expression> classExpr; public SuperExpr() { + this(Range.UNKNOWN, null); } - public SuperExpr(final Expression classExpr) { - setClassExpr(classExpr); + public SuperExpr(final Optional<Expression> classExpr) { + this(Range.UNKNOWN, classExpr); } - public SuperExpr(final Range range, final Expression classExpr) { + public SuperExpr(final Range range, final Optional<Expression> classExpr) { super(range); setClassExpr(classExpr); } @@ -52,12 +57,12 @@ public final class SuperExpr extends Expression { v.visit(this, arg); } - public Expression getClassExpr() { + public Optional<Expression> getClassExpr() { return classExpr; } - public SuperExpr setClassExpr(final Expression classExpr) { - this.classExpr = classExpr; + public SuperExpr setClassExpr(final Optional<Expression> classExpr) { + this.classExpr = assertNotNull(classExpr); setAsParentNodeOf(this.classExpr); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ThisExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ThisExpr.java index 117fed53d..b7e457658 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ThisExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/ThisExpr.java @@ -25,21 +25,27 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; + /** * @author Julio Vilmar Gesser */ public final class ThisExpr extends Expression { - private Expression classExpr; + private Optional<Expression> classExpr; public ThisExpr() { + this(Range.UNKNOWN, none()); } - public ThisExpr(final Expression classExpr) { - setClassExpr(classExpr); + public ThisExpr(final Optional<Expression> classExpr) { + this(Range.UNKNOWN, classExpr); } - public ThisExpr(final Range range, final Expression classExpr) { + public ThisExpr(final Range range, final Optional<Expression> classExpr) { super(range); setClassExpr(classExpr); } @@ -52,12 +58,12 @@ public final class ThisExpr extends Expression { v.visit(this, arg); } - public Expression getClassExpr() { + public Optional<Expression> getClassExpr() { return classExpr; } - public ThisExpr setClassExpr(final Expression classExpr) { - this.classExpr = classExpr; + public ThisExpr setClassExpr(final Optional<Expression> classExpr) { + this.classExpr = assertNotNull(classExpr); setAsParentNodeOf(this.classExpr); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/TypeExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/TypeExpr.java index 28b14e19f..7a3bd07f6 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/TypeExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/TypeExpr.java @@ -23,20 +23,25 @@ package com.github.javaparser.ast.expr; import com.github.javaparser.Range; import com.github.javaparser.ast.nodeTypes.NodeWithType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * This class is just instantiated as scopes for MethodReferenceExpr nodes to encapsulate Types. * @author Raquel Pau * */ -public class TypeExpr extends Expression implements NodeWithType<TypeExpr> { +public class TypeExpr extends Expression implements NodeWithType<TypeExpr, Type<?>> { private Type<?> type; - public TypeExpr(){} + public TypeExpr() { + this(Range.UNKNOWN, new ClassOrInterfaceType()); + } public TypeExpr(Range range, Type<?> type) { super(range); @@ -60,7 +65,7 @@ public class TypeExpr extends Expression implements NodeWithType<TypeExpr> { @Override public TypeExpr setType(Type<?> type) { - this.type = type; + this.type = assertNotNull(type); setAsParentNodeOf(this.type); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/UnaryExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/UnaryExpr.java index eef9101ee..1331f6be7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/UnaryExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/UnaryExpr.java @@ -37,8 +37,8 @@ public final class UnaryExpr extends Expression { preDecrement, // -- not, // ! inverse, // ~ - posIncrement, // ++ - posDecrement, // -- + postIncrement, // ++ + postDecrement, // -- } private Expression expr; @@ -46,11 +46,11 @@ public final class UnaryExpr extends Expression { private Operator op; public UnaryExpr() { + this(Range.UNKNOWN, new IntegerLiteralExpr(), Operator.postIncrement); } public UnaryExpr(final Expression expr, final Operator op) { - setExpr(expr); - setOperator(op); + this(Range.UNKNOWN, expr, op); } public UnaryExpr(final Range range, final Expression expr, final Operator op) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/VariableDeclarationExpr.java b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/VariableDeclarationExpr.java index 5bb0f6299..2e5deb40a 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/expr/VariableDeclarationExpr.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/expr/VariableDeclarationExpr.java @@ -21,22 +21,23 @@ package com.github.javaparser.ast.expr; -import static com.github.javaparser.utils.Utils.ensureNotNull; -import static java.util.Collections.*; +import static com.github.javaparser.ast.NodeList.nodeList; +import static com.github.javaparser.utils.Utils.assertNotNull; import java.util.Arrays; import java.util.EnumSet; -import java.util.List; import java.util.stream.Collectors; import com.github.javaparser.Range; import com.github.javaparser.ast.ArrayBracketPair; import com.github.javaparser.ast.Modifier; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.body.VariableDeclarator; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.nodeTypes.NodeWithElementType; import com.github.javaparser.ast.nodeTypes.NodeWithModifiers; import com.github.javaparser.ast.nodeTypes.NodeWithVariables; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; @@ -52,58 +53,84 @@ public final class VariableDeclarationExpr extends Expression implements private EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); - private List<AnnotationExpr> annotations; + private NodeList<AnnotationExpr> annotations = new NodeList<>(); private Type elementType; - private List<VariableDeclarator> variables; + private NodeList<VariableDeclarator> variables; - private List<ArrayBracketPair> arrayBracketPairsAfterType; + private NodeList<ArrayBracketPair> arrayBracketPairsAfterType; public VariableDeclarationExpr() { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + new ClassOrInterfaceType(), + new NodeList<>(), + new NodeList<>()); } public VariableDeclarationExpr(final Type elementType, String variableName) { - setElementType(elementType); - setVariables(singletonList(new VariableDeclarator(variableName))); + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + elementType, + nodeList(new VariableDeclarator(variableName)), + new NodeList<>()); } public VariableDeclarationExpr(final Type elementType, VariableDeclarator var) { - setElementType(elementType); - setVariables(singletonList(var)); + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + elementType, + nodeList(var), + new NodeList<>()); } public VariableDeclarationExpr(final Type elementType, String variableName, Modifier... modifiers) { - setElementType(elementType); - setVariables(singletonList(new VariableDeclarator(variableName))); - setModifiers(Arrays.stream(modifiers) - .collect(Collectors.toCollection(() -> EnumSet.noneOf(Modifier.class)))); + this(Range.UNKNOWN, + Arrays.stream(modifiers).collect(Collectors.toCollection(() -> EnumSet.noneOf(Modifier.class))), + new NodeList<>(), + elementType, + nodeList(new VariableDeclarator(variableName)), + new NodeList<>()); } public VariableDeclarationExpr(final Type elementType, VariableDeclarator var, Modifier... modifiers) { - setElementType(elementType); - setVariables(singletonList(var)); - setModifiers(Arrays.stream(modifiers) - .collect(Collectors.toCollection(() -> EnumSet.noneOf(Modifier.class)))); + this(Range.UNKNOWN, + Arrays.stream(modifiers).collect(Collectors.toCollection(() -> EnumSet.noneOf(Modifier.class))), + new NodeList<>(), + elementType, + nodeList(var), + new NodeList<>()); } - public VariableDeclarationExpr(final Type elementType, final List<VariableDeclarator> variables) { - setElementType(elementType); - setVariables(variables); + public VariableDeclarationExpr(final Type elementType, final NodeList<VariableDeclarator> variables) { + this(Range.UNKNOWN, + EnumSet.noneOf(Modifier.class), + new NodeList<>(), + elementType, + variables, + new NodeList<>()); } public VariableDeclarationExpr(final EnumSet<Modifier> modifiers, final Type elementType, - final List<VariableDeclarator> variables) { - setModifiers(modifiers); - setElementType(elementType); - setVariables(variables); + final NodeList<VariableDeclarator> variables) { + this(Range.UNKNOWN, + modifiers, + new NodeList<>(), + elementType, + variables, + new NodeList<>()); } public VariableDeclarationExpr(final Range range, - final EnumSet<Modifier> modifiers, final List<AnnotationExpr> annotations, + final EnumSet<Modifier> modifiers, + final NodeList<AnnotationExpr> annotations, final Type elementType, - final List<VariableDeclarator> variables, - final List<ArrayBracketPair> arrayBracketPairsAfterType) { + final NodeList<VariableDeclarator> variables, + final NodeList<ArrayBracketPair> arrayBracketPairsAfterType) { super(range); setModifiers(modifiers); setAnnotations(annotations); @@ -132,8 +159,7 @@ public final class VariableDeclarationExpr extends Expression implements } @Override - public List<AnnotationExpr> getAnnotations() { - annotations = ensureNotNull(annotations); + public NodeList<AnnotationExpr> getAnnotations() { return annotations; } @@ -154,14 +180,13 @@ public final class VariableDeclarationExpr extends Expression implements } @Override - public List<VariableDeclarator> getVariables() { - variables = ensureNotNull(variables); + public NodeList<VariableDeclarator> getVariables() { return variables; } @Override - public VariableDeclarationExpr setAnnotations(final List<AnnotationExpr> annotations) { - this.annotations = annotations; + public VariableDeclarationExpr setAnnotations(final NodeList<AnnotationExpr> annotations) { + this.annotations = assertNotNull(annotations); setAsParentNodeOf(this.annotations); return this; } @@ -180,20 +205,19 @@ public final class VariableDeclarationExpr extends Expression implements } @Override - public VariableDeclarationExpr setVariables(final List<VariableDeclarator> variables) { + public VariableDeclarationExpr setVariables(final NodeList<VariableDeclarator> variables) { this.variables = variables; setAsParentNodeOf(this.variables); return this; } - public List<ArrayBracketPair> getArrayBracketPairsAfterElementType() { - arrayBracketPairsAfterType = ensureNotNull(arrayBracketPairsAfterType); + public NodeList<ArrayBracketPair> getArrayBracketPairsAfterElementType() { return arrayBracketPairsAfterType; } @Override - public VariableDeclarationExpr setArrayBracketPairsAfterElementType(List<ArrayBracketPair> arrayBracketPairsAfterType) { - this.arrayBracketPairsAfterType = arrayBracketPairsAfterType; + public VariableDeclarationExpr setArrayBracketPairsAfterElementType(NodeList<ArrayBracketPair> arrayBracketPairsAfterType) { + this.arrayBracketPairsAfterType = assertNotNull(arrayBracketPairsAfterType); setAsParentNodeOf(arrayBracketPairsAfterType); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/imports/ImportDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/imports/ImportDeclaration.java index 4e82e65ad..88f39c257 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/imports/ImportDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/imports/ImportDeclaration.java @@ -48,7 +48,7 @@ import static com.github.javaparser.utils.Utils.assertNotNull; */ public abstract class ImportDeclaration extends Node { public ImportDeclaration() { - super(); + this(Range.UNKNOWN); } public ImportDeclaration(Range range) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/imports/SingleStaticImportDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/imports/SingleStaticImportDeclaration.java index 969a46fa2..649c71f58 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/imports/SingleStaticImportDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/imports/SingleStaticImportDeclaration.java @@ -18,7 +18,7 @@ public class SingleStaticImportDeclaration extends ImportDeclaration { private String staticMember; public SingleStaticImportDeclaration() { - this(Range.UNKNOWN, new ClassOrInterfaceType(), ""); + this(Range.UNKNOWN, new ClassOrInterfaceType(), "empty"); } public SingleStaticImportDeclaration(Range range, ClassOrInterfaceType type, String staticMember) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/imports/TypeImportOnDemandDeclaration.java b/javaparser-core/src/main/java/com/github/javaparser/ast/imports/TypeImportOnDemandDeclaration.java index 0f897c385..43963ec74 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/imports/TypeImportOnDemandDeclaration.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/imports/TypeImportOnDemandDeclaration.java @@ -21,7 +21,7 @@ public class TypeImportOnDemandDeclaration extends ImportDeclaration { private NameExpr name; public TypeImportOnDemandDeclaration() { - this(Range.UNKNOWN, name("")); + this(Range.UNKNOWN, name("empty")); } public TypeImportOnDemandDeclaration(Range range, NameExpr name) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithAnnotations.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithAnnotations.java index d159eff17..37320aa65 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithAnnotations.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithAnnotations.java @@ -21,12 +21,13 @@ package com.github.javaparser.ast.nodeTypes; +import static com.github.javaparser.ast.NodeList.*; import static com.github.javaparser.ast.expr.NameExpr.name; import java.lang.annotation.Annotation; -import java.util.List; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.expr.MarkerAnnotationExpr; import com.github.javaparser.ast.expr.NormalAnnotationExpr; @@ -39,9 +40,9 @@ import com.github.javaparser.ast.expr.SingleMemberAnnotationExpr; * @since July 2014 */ public interface NodeWithAnnotations<T> { - List<AnnotationExpr> getAnnotations(); + NodeList<AnnotationExpr> getAnnotations(); - T setAnnotations(List<AnnotationExpr> annotations); + T setAnnotations(NodeList<AnnotationExpr> annotations); /** * Annotates this @@ -51,7 +52,7 @@ public interface NodeWithAnnotations<T> { */ default NormalAnnotationExpr addAnnotation(String name) { NormalAnnotationExpr normalAnnotationExpr = new NormalAnnotationExpr( - name(name), null); + name(name), new NodeList<>()); getAnnotations().add(normalAnnotationExpr); normalAnnotationExpr.setParentNode((Node) this); return normalAnnotationExpr; diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithArguments.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithArguments.java new file mode 100644 index 000000000..a130b200d --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithArguments.java @@ -0,0 +1,22 @@ +package com.github.javaparser.ast.nodeTypes; + +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.expr.Expression; +import com.github.javaparser.ast.expr.NameExpr; + +public interface NodeWithArguments<T> { + T setArgs(NodeList<Expression> args); + + NodeList<Expression> getArgs(); + + default T addArgument(String arg) { + addArgument(new NameExpr(arg)); + return (T) this; + } + + default T addArgument(Expression arg) { + getArgs().add(arg); + return (T) this; + } + +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithElementType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithElementType.java index 21a41bad8..bbd6374a9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithElementType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithElementType.java @@ -24,6 +24,7 @@ package com.github.javaparser.ast.nodeTypes; import com.github.javaparser.ast.ArrayBracketPair; import com.github.javaparser.ast.CompilationUnit; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.body.MethodDeclaration; import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; @@ -51,9 +52,9 @@ public interface NodeWithElementType<T> { */ T setElementType(Type<?> elementType); - List<ArrayBracketPair> getArrayBracketPairsAfterElementType(); + NodeList<ArrayBracketPair> getArrayBracketPairsAfterElementType(); - T setArrayBracketPairsAfterElementType(List<ArrayBracketPair> arrayBracketPairsAfterType); + T setArrayBracketPairsAfterElementType(NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType); /** * Sets this type to this class and try to import it to the {@link CompilationUnit} if needed diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithExtends.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithExtends.java index 7189674dc..335dbda0d 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithExtends.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithExtends.java @@ -1,14 +1,13 @@ package com.github.javaparser.ast.nodeTypes;
-import java.util.List;
-
import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.type.ClassOrInterfaceType;
public interface NodeWithExtends<T> {
- List<ClassOrInterfaceType> getExtends();
+ NodeList<ClassOrInterfaceType> getExtends();
- T setExtends(final List<ClassOrInterfaceType> extendsList);
+ T setExtends(NodeList<ClassOrInterfaceType> extendsList);
/**
* Add an extends to this and automatically add the import
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithImplements.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithImplements.java index 184449f60..4c3ceee88 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithImplements.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithImplements.java @@ -3,12 +3,13 @@ package com.github.javaparser.ast.nodeTypes; import java.util.List;
import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.type.ClassOrInterfaceType;
public interface NodeWithImplements<T> {
- List<ClassOrInterfaceType> getImplements();
+ NodeList<ClassOrInterfaceType> getImplements();
- T setImplements(List<ClassOrInterfaceType> implementsList);
+ T setImplements(NodeList<ClassOrInterfaceType> implementsList);
/**
* Add an implements to this
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithJavaDoc.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithJavaDoc.java index 7f04e46b5..0288ee610 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithJavaDoc.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithJavaDoc.java @@ -24,6 +24,10 @@ package com.github.javaparser.ast.nodeTypes; import com.github.javaparser.ast.Node; import com.github.javaparser.ast.comments.JavadocComment; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.some; + /** * Node which can be documented through a Javadoc comment. */ @@ -31,9 +35,9 @@ public interface NodeWithJavaDoc<T> { /** * Gets the JavaDoc for this node. You can set the JavaDoc by calling setComment with a JavadocComment. * - * @return The JavaDoc for this node if it exists, null if it doesn't. + * @return The optional JavaDoc for this node */ - JavadocComment getJavaDoc(); + Optional<JavadocComment> getJavaDoc(); /** * Use this to store additional information to this node. @@ -42,7 +46,7 @@ public interface NodeWithJavaDoc<T> { */ @SuppressWarnings("unchecked") default T setJavaDocComment(String comment) { - ((Node) this).setComment(new JavadocComment(comment)); + ((Node) this).setComment(some(new JavadocComment(comment))); return (T) this; } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithMembers.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithMembers.java index a14b3ddc8..69910687b 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithMembers.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithMembers.java @@ -13,6 +13,7 @@ import java.util.stream.Stream; import com.github.javaparser.ast.Modifier;
import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.body.BodyDeclaration;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.body.FieldDeclaration;
@@ -33,9 +34,9 @@ import com.github.javaparser.ast.type.Type; *
*/
public interface NodeWithMembers<T> {
- List<BodyDeclaration<?>> getMembers();
+ NodeList<BodyDeclaration<?>> getMembers();
- T setMembers(List<BodyDeclaration<?>> members);
+ T setMembers(NodeList<BodyDeclaration<?>> members);
/**
* Add a field to this and automatically add the import of the type if needed
@@ -72,14 +73,12 @@ public interface NodeWithMembers<T> { */
default FieldDeclaration addField(Type<?> type, String name, Modifier... modifiers) {
FieldDeclaration fieldDeclaration = new FieldDeclaration();
- fieldDeclaration.setParentNode((Node) this);
+ getMembers().add(fieldDeclaration);
VariableDeclarator variable = new VariableDeclarator(new VariableDeclaratorId(name));
fieldDeclaration.getVariables().add(variable);
- variable.setParentNode(fieldDeclaration);
fieldDeclaration.setModifiers(Arrays.stream(modifiers)
.collect(toCollection(() -> EnumSet.noneOf(Modifier.class))));
variable.setType(type);
- getMembers().add(fieldDeclaration);
return fieldDeclaration;
}
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithParameters.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithParameters.java index d22ab3c83..30bdc719c 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithParameters.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithParameters.java @@ -3,15 +3,16 @@ package com.github.javaparser.ast.nodeTypes; import java.util.List;
import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.body.Parameter;
import com.github.javaparser.ast.body.VariableDeclaratorId;
import com.github.javaparser.ast.type.ClassOrInterfaceType;
import com.github.javaparser.ast.type.Type;
public interface NodeWithParameters<T> {
- List<Parameter> getParameters();
+ NodeList<Parameter> getParameters();
- T setParameters(List<Parameter> parameters);
+ T setParameters(NodeList<Parameter> parameters);
default T addParameter(Type type, String name) {
return addParameter(new Parameter(type, new VariableDeclaratorId(name)));
@@ -35,7 +36,6 @@ public interface NodeWithParameters<T> { @SuppressWarnings("unchecked")
default T addParameter(Parameter parameter) {
getParameters().add(parameter);
- parameter.setParentNode((Node) this);
return (T) this;
}
@@ -61,7 +61,6 @@ public interface NodeWithParameters<T> { default Parameter addAndGetParameter(Parameter parameter) {
getParameters().add(parameter);
- parameter.setParentNode((Node) this);
return parameter;
}
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithStatements.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithStatements.java index 9b5870073..d6f76596b 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithStatements.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithStatements.java @@ -1,17 +1,16 @@ package com.github.javaparser.ast.nodeTypes;
-import java.util.List;
-
import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.expr.Expression;
import com.github.javaparser.ast.expr.NameExpr;
import com.github.javaparser.ast.stmt.ExpressionStmt;
import com.github.javaparser.ast.stmt.Statement;
public interface NodeWithStatements<T> {
- List<Statement> getStmts();
+ NodeList<Statement> getStmts();
- T setStmts(final List<Statement> stmts);
+ T setStmts(final NodeList<Statement> stmts);
@SuppressWarnings("unchecked")
default T addStatement(Statement statement) {
@@ -64,4 +63,8 @@ public interface NodeWithStatements<T> { default ExpressionStmt addAndGetStatement(String statement) {
return addAndGetStatement(new NameExpr(statement));
}
+
+ default boolean isEmpty() {
+ return getStmts().isEmpty();
+ }
}
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithThrowable.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithThrowable.java index 59b176ac5..8ff389da3 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithThrowable.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithThrowable.java @@ -1,15 +1,14 @@ package com.github.javaparser.ast.nodeTypes;
-import java.util.List;
-
import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.type.ClassOrInterfaceType;
import com.github.javaparser.ast.type.ReferenceType;
public interface NodeWithThrowable<T> {
- T setThrows(List<ReferenceType> throws_);
+ T setThrows(NodeList<ReferenceType<?>> throws_);
- List<ReferenceType> getThrows();
+ NodeList<ReferenceType<?>> getThrows();
/**
* Adds this type to the throws clause
@@ -18,7 +17,7 @@ public interface NodeWithThrowable<T> { * @return this
*/
@SuppressWarnings("unchecked")
- default T addThrows(ReferenceType throwType) {
+ default T addThrows(ReferenceType<?> throwType) {
getThrows().add(throwType);
throwType.setParentNode((Node) this);
return (T) this;
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithType.java index e32dbd925..b567fa95b 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithType.java @@ -34,13 +34,13 @@ import com.github.javaparser.ast.type.Type; *
* @since 2.3.1
*/
-public interface NodeWithType<T> {
+public interface NodeWithType<N, T extends Type<?>> {
/**
* Gets the type
*
* @return the type
*/
- Type<?> getType();
+ T getType();
/**
* Sets the type
@@ -48,7 +48,7 @@ public interface NodeWithType<T> { * @param type the type
* @return this
*/
- T setType(Type<?> type);
+ N setType(T type);
/**
* Sets this type to this class and try to import it to the {@link CompilationUnit} if needed
@@ -56,14 +56,14 @@ public interface NodeWithType<T> { * @param typeClass the type
* @return this
*/
- default T setType(Class<?> typeClass) {
+ default N setType(Class<?> typeClass) {
((Node) this).tryAddImportToParentCompilationUnit(typeClass);
- return setType(new ClassOrInterfaceType(typeClass.getSimpleName()));
+ return setType((T) new ClassOrInterfaceType(typeClass.getSimpleName()));
}
- default T setType(final String type) {
+ default N setType(final String type) {
ClassOrInterfaceType classOrInterfaceType = new ClassOrInterfaceType(type);
- return setType(classOrInterfaceType);
+ return setType((T) classOrInterfaceType);
}
}
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithTypeArguments.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithTypeArguments.java index 799d55444..04c001f99 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithTypeArguments.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithTypeArguments.java @@ -21,41 +21,43 @@ package com.github.javaparser.ast.nodeTypes; +import static com.github.javaparser.ast.NodeList.*; import static com.github.javaparser.utils.Utils.arrayToList; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; import java.util.LinkedList; import java.util.List; +import java.util.Optional; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.type.Type; /** * A node that can have type arguments. * <pre> * new X(); --> typeArguments == null - * new X<>(); --> typeArguments.types = [], typeArguments.diamondOperator=true - * new X<C,D>(); --> typeArguments.types = [C,D], typeArguments.diamondOperator=false + * new X<>(); --> typeArguments = [], diamondOperator = true + * new X<C,D>(); --> typeArguments = [C,D], diamondOperator = false * </pre> */ public interface NodeWithTypeArguments<T> { /** * @return the types that can be found in the type arguments: <String, Integer>. */ - List<Type<?>> getTypeArguments(); + Optional<NodeList<Type<?>>> getTypeArguments(); /** * Allows you to set the generic arguments * @param typeArguments The list of types of the generics */ - T setTypeArguments(List<Type<?>> typeArguments); + T setTypeArguments(Optional<NodeList<Type<?>>> typeArguments); /** * @return whether the type arguments look like <>. */ default boolean isUsingDiamondOperator() { - if(getTypeArguments()==null){ - return false; - } - return getTypeArguments().isEmpty(); + return getTypeArguments().isPresent() && getTypeArguments().get().isEmpty(); } /** @@ -63,8 +65,7 @@ public interface NodeWithTypeArguments<T> { */ @SuppressWarnings("unchecked") default T setDiamondOperator() { - final List<Type<?>> empty = new LinkedList<>(); - setTypeArguments(empty); + setTypeArguments(some(new NodeList<>())); return (T) this; } @@ -73,13 +74,13 @@ public interface NodeWithTypeArguments<T> { */ @SuppressWarnings("unchecked") default T removeTypeArguments() { - setTypeArguments((List<Type<?>>) null); + setTypeArguments(none()); return (T) this; } @SuppressWarnings("unchecked") default T setTypeArguments(Type<?>... typeArguments) { - setTypeArguments(arrayToList(typeArguments)); + setTypeArguments(some(nodeList(typeArguments))); return (T) this; } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithTypeParameters.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithTypeParameters.java new file mode 100644 index 000000000..86d9dedc3 --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithTypeParameters.java @@ -0,0 +1,22 @@ +package com.github.javaparser.ast.nodeTypes; + +import com.github.javaparser.ast.NodeList; +import com.github.javaparser.ast.type.TypeParameter; + +/** + * A node that can have type parameters. + * <pre> + * class X {} --> typeParameters == [] + * class X<> {} --> does not occur. + * class X<C,D> {} --> typeParameters = [C,D] + * </pre> + */ +public interface NodeWithTypeParameters<T> { + NodeList<TypeParameter> getTypeParameters(); + + T setTypeParameters(NodeList<TypeParameter> typeParameters); + + default boolean isGeneric() { + return getTypeParameters().size() > 0; + } +} diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithVariables.java b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithVariables.java index 2c6702ac4..0989b2972 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithVariables.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/nodeTypes/NodeWithVariables.java @@ -21,6 +21,7 @@ package com.github.javaparser.ast.nodeTypes; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.body.FieldDeclaration; import com.github.javaparser.ast.body.VariableDeclarator; @@ -30,7 +31,7 @@ import java.util.List; * A node which has a list of variables. */ public interface NodeWithVariables<T> { - List<VariableDeclarator> getVariables(); + NodeList<VariableDeclarator> getVariables(); - T setVariables(List<VariableDeclarator> variables); + T setVariables(NodeList<VariableDeclarator> variables); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/AssertStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/AssertStmt.java index 85a34a847..ad93c7ceb 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/AssertStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/AssertStmt.java @@ -22,10 +22,17 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.expr.BooleanLiteralExpr; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; + /** * @author Julio Vilmar Gesser */ @@ -33,26 +40,24 @@ public final class AssertStmt extends Statement { private Expression check; - private Expression msg; + private Optional<Expression> msg; public AssertStmt() { + this(Range.UNKNOWN, new BooleanLiteralExpr(), none()); } public AssertStmt(final Expression check) { - setCheck(check); + this(Range.UNKNOWN, check, none()); } public AssertStmt(final Expression check, final Expression msg) { - setCheck(check); - setMessage(msg); + this(Range.UNKNOWN, check, some(msg)); } - public AssertStmt(final Range range, final Expression check, final Expression msg) { + public AssertStmt(final Range range, final Expression check, final Optional<Expression> msg) { super(range); - setCheck(check); setMessage(msg); - } @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { @@ -67,18 +72,18 @@ public final class AssertStmt extends Statement { return check; } - public Expression getMessage() { + public Optional<Expression> getMessage() { return msg; } public AssertStmt setCheck(final Expression check) { - this.check = check; + this.check = assertNotNull(check); setAsParentNodeOf(this.check); return this; } - public AssertStmt setMessage(final Expression msg) { - this.msg = msg; + public AssertStmt setMessage(final Optional<Expression> msg) { + this.msg = assertNotNull(msg); setAsParentNodeOf(this.msg); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BlockStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BlockStmt.java index 31cbfa391..53d3957f1 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BlockStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BlockStmt.java @@ -21,11 +21,10 @@ package com.github.javaparser.ast.stmt; -import static com.github.javaparser.utils.Utils.ensureNotNull; - -import java.util.List; +import static com.github.javaparser.utils.Utils.assertNotNull; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithStatements; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; @@ -35,16 +34,18 @@ import com.github.javaparser.ast.visitor.VoidVisitor; */ public final class BlockStmt extends Statement implements NodeWithStatements<BlockStmt> { - private List<Statement> stmts; + private NodeList<Statement> stmts; public BlockStmt() { + this(Range.UNKNOWN, new NodeList<>()); } - public BlockStmt(final List<Statement> stmts) { - setStmts(stmts); + public BlockStmt(final NodeList<Statement> stmts) { + this(Range.UNKNOWN, stmts); + } - public BlockStmt(final Range range, final List<Statement> stmts) { + public BlockStmt(final Range range, final NodeList<Statement> stmts) { super(range); setStmts(stmts); } @@ -60,14 +61,13 @@ public final class BlockStmt extends Statement implements NodeWithStatements<Blo } @Override - public List<Statement> getStmts() { - stmts = ensureNotNull(stmts); + public NodeList<Statement> getStmts() { return stmts; } @Override - public BlockStmt setStmts(final List<Statement> stmts) { - this.stmts = stmts; + public BlockStmt setStmts(final NodeList<Statement> stmts) { + this.stmts = assertNotNull(stmts); setAsParentNodeOf(this.stmts); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BreakStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BreakStmt.java index 04c39fb9f..74bf059f1 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BreakStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/BreakStmt.java @@ -25,21 +25,28 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; + /** * @author Julio Vilmar Gesser */ public final class BreakStmt extends Statement { - private String id; + private Optional<String> id; public BreakStmt() { + this(Range.UNKNOWN, none()); } public BreakStmt(final String id) { - this.id = id; + this(Range.UNKNOWN, some(id)); } - public BreakStmt(final Range range, final String id) { + public BreakStmt(final Range range, final Optional<String> id) { super(range); this.id = id; } @@ -52,12 +59,12 @@ public final class BreakStmt extends Statement { v.visit(this, arg); } - public String getId() { + public Optional<String> getId() { return id; } - public BreakStmt setId(final String id) { - this.id = id; + public BreakStmt setId(final Optional<String> id) { + this.id = assertNotNull(id); return this; } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/CatchClause.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/CatchClause.java index a1f300544..84b18ee73 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/CatchClause.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/CatchClause.java @@ -24,17 +24,17 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; import com.github.javaparser.ast.Modifier; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.body.Parameter; import com.github.javaparser.ast.body.VariableDeclaratorId; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt; -import com.github.javaparser.ast.type.ReferenceType; +import com.github.javaparser.ast.type.ClassOrInterfaceType; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import java.util.EnumSet; -import java.util.List; /** * @author Julio Vilmar Gesser @@ -46,21 +46,34 @@ public final class CatchClause extends Node implements NodeWithBlockStmt<CatchCl private BlockStmt catchBlock; public CatchClause() { + this(Range.UNKNOWN, new Parameter(), new BlockStmt()); } public CatchClause(final Parameter param, final BlockStmt catchBlock) { - setParam(param); - setBody(catchBlock); + this(Range.UNKNOWN, param, catchBlock); + } + + public CatchClause(final EnumSet<Modifier> exceptModifier, + final NodeList<AnnotationExpr> exceptAnnotations, + final ClassOrInterfaceType exceptType, + final VariableDeclaratorId exceptId, + final BlockStmt catchBlock) { + this(Range.UNKNOWN, + new Parameter(Range.UNKNOWN, + exceptModifier, + exceptAnnotations, + exceptType, + new NodeList<>(), + false, + exceptId), + catchBlock); } public CatchClause(final Range range, - final EnumSet<Modifier> exceptModifier, - final List<AnnotationExpr> exceptAnnotations, - final Type exceptType, - final VariableDeclaratorId exceptId, + final Parameter parameter, final BlockStmt catchBlock) { super(range); - setParam(new Parameter(range, exceptModifier, exceptAnnotations, exceptType, null, false, exceptId)); + setParam(parameter); setBody(catchBlock); } @@ -90,8 +103,6 @@ public final class CatchClause extends Node implements NodeWithBlockStmt<CatchCl /** * Use {@link #setBody(BlockStmt)} instead - * - * @param catchBlock */ @Deprecated public CatchClause setCatchBlock(final BlockStmt catchBlock) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ContinueStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ContinueStmt.java index 4ba7faa7b..03fd5f0a9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ContinueStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ContinueStmt.java @@ -25,21 +25,27 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; + /** * @author Julio Vilmar Gesser */ public final class ContinueStmt extends Statement { - private String id; + private Optional<String> id; public ContinueStmt() { + this(Range.UNKNOWN, none()); } public ContinueStmt(final String id) { - this.id = id; + this(Range.UNKNOWN, some(id)); } - public ContinueStmt(Range range, final String id) { + public ContinueStmt(Range range, final Optional<String> id) { super(range); this.id = id; } @@ -52,11 +58,11 @@ public final class ContinueStmt extends Statement { v.visit(this, arg); } - public String getId() { + public Optional<String> getId() { return id; } - public ContinueStmt setId(final String id) { + public ContinueStmt setId(final Optional<String> id) { this.id = id; return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/DoStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/DoStmt.java index 8f293ecab..00614de99 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/DoStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/DoStmt.java @@ -22,6 +22,7 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.expr.BooleanLiteralExpr; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.nodeTypes.NodeWithBody; import com.github.javaparser.ast.visitor.GenericVisitor; @@ -37,11 +38,11 @@ public final class DoStmt extends Statement implements NodeWithBody<DoStmt> { private Expression condition; public DoStmt() { + this(Range.UNKNOWN, new EmptyStmt(), new BooleanLiteralExpr()); } public DoStmt(final Statement body, final Expression condition) { - setBody(body); - setCondition(condition); + this(Range.UNKNOWN, body, condition); } public DoStmt(Range range, final Statement body, final Expression condition) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/EmptyStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/EmptyStmt.java index 00709806d..36e56795d 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/EmptyStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/EmptyStmt.java @@ -31,6 +31,7 @@ import com.github.javaparser.ast.visitor.VoidVisitor; public final class EmptyStmt extends Statement { public EmptyStmt() { + this(Range.UNKNOWN); } public EmptyStmt(Range range) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExplicitConstructorInvocationStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExplicitConstructorInvocationStmt.java index e29205b84..3aebf88b4 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExplicitConstructorInvocationStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExplicitConstructorInvocationStmt.java @@ -22,42 +22,43 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; import com.github.javaparser.ast.type.Type; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser */ public final class ExplicitConstructorInvocationStmt extends Statement implements NodeWithTypeArguments<ExplicitConstructorInvocationStmt> { - private List<Type<?>> typeArguments; + private Optional<NodeList<Type<?>>> typeArguments; private boolean isThis; - private Expression expr; + private Optional<Expression> expr; - private List<Expression> args; + private NodeList<Expression> args; public ExplicitConstructorInvocationStmt() { + this(Range.UNKNOWN, none(), true, none(), new NodeList<>()); } public ExplicitConstructorInvocationStmt(final boolean isThis, - final Expression expr, final List<Expression> args) { - setThis(isThis); - setExpr(expr); - setArgs(args); + final Optional<Expression> expr, final NodeList<Expression> args) { + this(Range.UNKNOWN, none(), isThis, expr, args); } public ExplicitConstructorInvocationStmt(Range range, - final List<Type<?>> typeArguments, final boolean isThis, - final Expression expr, final List<Expression> args) { + final Optional<NodeList<Type<?>>> typeArguments, final boolean isThis, + final Optional<Expression> expr, final NodeList<Expression> args) { super(range); setTypeArguments(typeArguments); setThis(isThis); @@ -75,12 +76,11 @@ public final class ExplicitConstructorInvocationStmt extends Statement implement v.visit(this, arg); } - public List<Expression> getArgs() { - args = ensureNotNull(args); + public NodeList<Expression> getArgs() { return args; } - public Expression getExpr() { + public Optional<Expression> getExpr() { return expr; } @@ -88,13 +88,13 @@ public final class ExplicitConstructorInvocationStmt extends Statement implement return isThis; } - public ExplicitConstructorInvocationStmt setArgs(final List<Expression> args) { - this.args = args; + public ExplicitConstructorInvocationStmt setArgs(final NodeList<Expression> args) { + this.args = assertNotNull(args); setAsParentNodeOf(this.args); return this; } - public ExplicitConstructorInvocationStmt setExpr(final Expression expr) { + public ExplicitConstructorInvocationStmt setExpr(final Optional<Expression> expr) { this.expr = expr; setAsParentNodeOf(this.expr); return this; @@ -106,13 +106,13 @@ public final class ExplicitConstructorInvocationStmt extends Statement implement } @Override - public List<Type<?>> getTypeArguments() { + public Optional<NodeList<Type<?>>> getTypeArguments() { return typeArguments; } @Override - public ExplicitConstructorInvocationStmt setTypeArguments(final List<Type<?>> types) { - this.typeArguments = types; + public ExplicitConstructorInvocationStmt setTypeArguments(final Optional<NodeList<Type<?>>> types) { + this.typeArguments = assertNotNull(types); setAsParentNodeOf(this.typeArguments); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExpressionStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExpressionStmt.java index 72d8a2e94..93dad73c3 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExpressionStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ExpressionStmt.java @@ -22,10 +22,13 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.expr.BooleanLiteralExpr; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -34,14 +37,14 @@ public final class ExpressionStmt extends Statement { private Expression expr; public ExpressionStmt() { + this(Range.UNKNOWN, new BooleanLiteralExpr()); } public ExpressionStmt(final Expression expr) { - setExpression(expr); + this(Range.UNKNOWN, expr); } - public ExpressionStmt(Range range, - final Expression expr) { + public ExpressionStmt(Range range, final Expression expr) { super(range); setExpression(expr); } @@ -59,7 +62,7 @@ public final class ExpressionStmt extends Statement { } public ExpressionStmt setExpression(final Expression expr) { - this.expr = expr; + this.expr = assertNotNull(expr); setAsParentNodeOf(this.expr); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForStmt.java index 52baddb7b..05ea27b06 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForStmt.java @@ -22,42 +22,46 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.nodeTypes.NodeWithBody; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser */ public final class ForStmt extends Statement implements NodeWithBody<ForStmt> { - private List<Expression> init; + private NodeList<Expression> init; - private Expression compare; + private Optional<Expression> compare; - private List<Expression> update; + private NodeList<Expression> update; private Statement body; public ForStmt() { + this(Range.UNKNOWN, + new NodeList<>(), + none(), + new NodeList<>(), + new EmptyStmt()); } - public ForStmt(final List<Expression> init, final Expression compare, - final List<Expression> update, final Statement body) { - setCompare(compare); - setInit(init); - setUpdate(update); - setBody(body); + public ForStmt(final NodeList<Expression> init, final Optional<Expression> compare, + final NodeList<Expression> update, final Statement body) { + this(Range.UNKNOWN, init, compare, update, body); } public ForStmt(Range range, - final List<Expression> init, final Expression compare, - final List<Expression> update, final Statement body) { + final NodeList<Expression> init, final Optional<Expression> compare, + final NodeList<Expression> update, final Statement body) { super(range); setCompare(compare); setInit(init); @@ -80,17 +84,15 @@ public final class ForStmt extends Statement implements NodeWithBody<ForStmt> { return body; } - public Expression getCompare() { + public Optional<Expression> getCompare() { return compare; } - public List<Expression> getInit() { - init = ensureNotNull(init); + public NodeList<Expression> getInit() { return init; } - public List<Expression> getUpdate() { - update = ensureNotNull(update); + public NodeList<Expression> getUpdate() { return update; } @@ -101,20 +103,20 @@ public final class ForStmt extends Statement implements NodeWithBody<ForStmt> { return this; } - public ForStmt setCompare(final Expression compare) { + public ForStmt setCompare(final Optional<Expression> compare) { this.compare = compare; setAsParentNodeOf(this.compare); return this; } - public ForStmt setInit(final List<Expression> init) { - this.init = init; + public ForStmt setInit(final NodeList<Expression> init) { + this.init = assertNotNull(init); setAsParentNodeOf(this.init); return this; } - public ForStmt setUpdate(final List<Expression> update) { - this.update = update; + public ForStmt setUpdate(final NodeList<Expression> update) { + this.update = assertNotNull(update); setAsParentNodeOf(this.update); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForeachStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForeachStmt.java index 3a94572b0..dd494cf7d 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForeachStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ForeachStmt.java @@ -29,6 +29,8 @@ import com.github.javaparser.ast.nodeTypes.NodeWithBody; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.ast.expr.NameExpr.name; + /** * @author Julio Vilmar Gesser */ @@ -41,13 +43,15 @@ public final class ForeachStmt extends Statement implements NodeWithBody<Foreach private Statement body; public ForeachStmt() { + this(Range.UNKNOWN, + new VariableDeclarationExpr(), + new NameExpr(), + new EmptyStmt()); } public ForeachStmt(final VariableDeclarationExpr var, final Expression iterable, final Statement body) { - setVariable(var); - setIterable(iterable); - setBody(body); + this(Range.UNKNOWN, var, iterable, body); } public ForeachStmt(Range range, @@ -61,15 +65,9 @@ public final class ForeachStmt extends Statement implements NodeWithBody<Foreach /** * Will create a {@link NameExpr} with the iterable param - * - * @param var - * @param iterable - * @param body */ public ForeachStmt(VariableDeclarationExpr var, String iterable, BlockStmt body) { - setVariable(var); - setIterable(new NameExpr(iterable)); - setBody(body); + this(Range.UNKNOWN, var, name(iterable), body); } @Override diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/IfStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/IfStmt.java index ace3ec8a5..930650288 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/IfStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/IfStmt.java @@ -22,10 +22,16 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.expr.BooleanLiteralExpr; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; + /** * @author Julio Vilmar Gesser */ @@ -35,19 +41,21 @@ public final class IfStmt extends Statement { private Statement thenStmt; - private Statement elseStmt; + private Optional<Statement> elseStmt; public IfStmt() { + this(Range.UNKNOWN, + new BooleanLiteralExpr(), + new EmptyStmt(), + none()); } - public IfStmt(final Expression condition, final Statement thenStmt, final Statement elseStmt) { - setCondition(condition); - setThenStmt(thenStmt); - setElseStmt(elseStmt); + public IfStmt(final Expression condition, final Statement thenStmt, final Optional<Statement> elseStmt) { + this(Range.UNKNOWN, condition, thenStmt, elseStmt); } public IfStmt(Range range, - final Expression condition, final Statement thenStmt, final Statement elseStmt) { + final Expression condition, final Statement thenStmt, final Optional<Statement> elseStmt) { super(range); setCondition(condition); setThenStmt(thenStmt); @@ -66,7 +74,7 @@ public final class IfStmt extends Statement { return condition; } - public Statement getElseStmt() { + public Optional<Statement> getElseStmt() { return elseStmt; } @@ -75,19 +83,19 @@ public final class IfStmt extends Statement { } public IfStmt setCondition(final Expression condition) { - this.condition = condition; + this.condition = assertNotNull(condition); setAsParentNodeOf(this.condition); return this; } - public IfStmt setElseStmt(final Statement elseStmt) { - this.elseStmt = elseStmt; + public IfStmt setElseStmt(final Optional<Statement> elseStmt) { + this.elseStmt = assertNotNull(elseStmt); setAsParentNodeOf(this.elseStmt); return this; } public IfStmt setThenStmt(final Statement thenStmt) { - this.thenStmt = thenStmt; + this.thenStmt = assertNotNull(thenStmt); setAsParentNodeOf(this.thenStmt); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/LabeledStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/LabeledStmt.java index ded1ad8d8..5e3c228a9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/LabeledStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/LabeledStmt.java @@ -25,6 +25,8 @@ import com.github.javaparser.Range; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -35,11 +37,11 @@ public final class LabeledStmt extends Statement { private Statement stmt; public LabeledStmt() { + this(Range.UNKNOWN, "empty", new EmptyStmt()); } public LabeledStmt(final String label, final Statement stmt) { - setLabel(label); - setStmt(stmt); + this(Range.UNKNOWN, label, stmt); } public LabeledStmt(Range range, final String label, final Statement stmt) { @@ -65,12 +67,12 @@ public final class LabeledStmt extends Statement { } public LabeledStmt setLabel(final String label) { - this.label = label; + this.label = assertNotNull(label); return this; } public LabeledStmt setStmt(final Statement stmt) { - this.stmt = stmt; + this.stmt = assertNotNull(stmt); setAsParentNodeOf(this.stmt); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ReturnStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ReturnStmt.java index 6ce31d0bf..0a87d59ae 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ReturnStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ReturnStmt.java @@ -22,37 +22,43 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.expr.BooleanLiteralExpr; import com.github.javaparser.ast.expr.Expression; -import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.ast.expr.NameExpr.name; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; + /** * @author Julio Vilmar Gesser */ public final class ReturnStmt extends Statement { - private Expression expr; + private Optional<Expression> expr; public ReturnStmt() { + this(Range.UNKNOWN, none()); } public ReturnStmt(final Expression expr) { - setExpr(expr); + this(Range.UNKNOWN, some(expr)); } - public ReturnStmt(Range range, final Expression expr) { + public ReturnStmt(Range range, final Optional<Expression> expr) { super(range); setExpr(expr); } /** * Will create a NameExpr with the string param - * - * @param expr */ public ReturnStmt(String expr) { - setExpr(new NameExpr(expr)); + this(Range.UNKNOWN, some(name(expr))); } @Override @@ -64,12 +70,12 @@ public final class ReturnStmt extends Statement { v.visit(this, arg); } - public Expression getExpr() { + public Optional<Expression> getExpr() { return expr; } - public ReturnStmt setExpr(final Expression expr) { - this.expr = expr; + public ReturnStmt setExpr(final Optional<Expression> expr) { + this.expr = assertNotNull(expr); setAsParentNodeOf(this.expr); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/Statement.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/Statement.java index eacfcc416..185bd8cf1 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/Statement.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/Statement.java @@ -28,12 +28,7 @@ import com.github.javaparser.ast.Node; * @author Julio Vilmar Gesser */ public abstract class Statement extends Node { - - public Statement() { - } - public Statement(final Range range) { super(range); } - } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchEntryStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchEntryStmt.java index e17e20e94..ff8912a73 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchEntryStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchEntryStmt.java @@ -22,34 +22,36 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.nodeTypes.NodeWithStatements; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser */ public final class SwitchEntryStmt extends Statement implements NodeWithStatements<SwitchEntryStmt> { - private Expression label; + private Optional<Expression> label; - private List<Statement> stmts; + private NodeList<Statement> stmts; public SwitchEntryStmt() { + this(Range.UNKNOWN, none(), new NodeList<>()); } - public SwitchEntryStmt(final Expression label, final List<Statement> stmts) { - setLabel(label); - setStmts(stmts); + public SwitchEntryStmt(final Optional<Expression> label, final NodeList<Statement> stmts) { + this(Range.UNKNOWN, label, stmts); } - public SwitchEntryStmt(Range range, final Expression label, - final List<Statement> stmts) { + public SwitchEntryStmt(Range range, final Optional<Expression> label, + final NodeList<Statement> stmts) { super(range); setLabel(label); setStmts(stmts); @@ -65,25 +67,24 @@ public final class SwitchEntryStmt extends Statement implements NodeWithStatemen v.visit(this, arg); } - public Expression getLabel() { + public Optional<Expression> getLabel() { return label; } @Override - public List<Statement> getStmts() { - stmts = ensureNotNull(stmts); + public NodeList<Statement> getStmts() { return stmts; } - public SwitchEntryStmt setLabel(final Expression label) { + public SwitchEntryStmt setLabel(final Optional<Expression> label) { this.label = label; setAsParentNodeOf(this.label); return this; } @Override - public SwitchEntryStmt setStmts(final List<Statement> stmts) { - this.stmts = stmts; + public SwitchEntryStmt setStmts(final NodeList<Statement> stmts) { + this.stmts = assertNotNull(stmts); setAsParentNodeOf(this.stmts); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchStmt.java index c909394b2..2ce900ff3 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SwitchStmt.java @@ -22,12 +22,13 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.Expression; +import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - +import static com.github.javaparser.ast.expr.NameExpr.name; import static com.github.javaparser.utils.Utils.*; /** @@ -37,19 +38,19 @@ public final class SwitchStmt extends Statement { private Expression selector; - private List<SwitchEntryStmt> entries; + private NodeList<SwitchEntryStmt> entries; public SwitchStmt() { + this(Range.UNKNOWN, new NameExpr(), new NodeList<>()); } public SwitchStmt(final Expression selector, - final List<SwitchEntryStmt> entries) { - setSelector(selector); - setEntries(entries); + final NodeList<SwitchEntryStmt> entries) { + this(Range.UNKNOWN, selector, entries); } public SwitchStmt(Range range, final Expression selector, - final List<SwitchEntryStmt> entries) { + final NodeList<SwitchEntryStmt> entries) { super(range); setSelector(selector); setEntries(entries); @@ -65,8 +66,7 @@ public final class SwitchStmt extends Statement { v.visit(this, arg); } - public List<SwitchEntryStmt> getEntries() { - entries = ensureNotNull(entries); + public NodeList<SwitchEntryStmt> getEntries() { return entries; } @@ -74,8 +74,8 @@ public final class SwitchStmt extends Statement { return selector; } - public SwitchStmt setEntries(final List<SwitchEntryStmt> entries) { - this.entries = entries; + public SwitchStmt setEntries(final NodeList<SwitchEntryStmt> entries) { + this.entries = assertNotNull(entries); setAsParentNodeOf(this.entries); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SynchronizedStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SynchronizedStmt.java index 1a9d2db5d..4a43a713b 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SynchronizedStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/SynchronizedStmt.java @@ -23,10 +23,13 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; import com.github.javaparser.ast.expr.Expression; +import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -37,18 +40,18 @@ public final class SynchronizedStmt extends Statement implements NodeWithBlockSt private BlockStmt block; public SynchronizedStmt() { + this(Range.UNKNOWN, new NameExpr(), new BlockStmt()); } public SynchronizedStmt(final Expression expr, final BlockStmt block) { - setExpr(expr); - setBlock(block); + this(Range.UNKNOWN, expr, block); } public SynchronizedStmt(Range range, final Expression expr, final BlockStmt block) { super(range); setExpr(expr); - setBlock(block); + setBody(block); } @Override @@ -63,7 +66,6 @@ public final class SynchronizedStmt extends Statement implements NodeWithBlockSt /** * @deprecated use {@link #getBody()} - * @return */ @Deprecated public BlockStmt getBlock() { @@ -76,17 +78,14 @@ public final class SynchronizedStmt extends Statement implements NodeWithBlockSt /** * @deprecated Use {@link #setBody(BlockStmt)} instead - * @param block */ @Deprecated public SynchronizedStmt setBlock(final BlockStmt block) { - this.block = block; - setAsParentNodeOf(this.block); - return this; + return setBody(block); } public SynchronizedStmt setExpr(final Expression expr) { - this.expr = expr; + this.expr = assertNotNull(expr); setAsParentNodeOf(this.expr); return this; } @@ -98,7 +97,7 @@ public final class SynchronizedStmt extends Statement implements NodeWithBlockSt @Override public SynchronizedStmt setBody(BlockStmt block) { - this.block = block; + this.block = assertNotNull(block); setAsParentNodeOf(this.block); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ThrowStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ThrowStmt.java index 180fdd04c..991299fa9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ThrowStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/ThrowStmt.java @@ -23,6 +23,7 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; import com.github.javaparser.ast.expr.Expression; +import com.github.javaparser.ast.expr.NameExpr; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; @@ -34,10 +35,11 @@ public final class ThrowStmt extends Statement { private Expression expr; public ThrowStmt() { + this(Range.UNKNOWN, new NameExpr()); } public ThrowStmt(final Expression expr) { - setExpr(expr); + this(Range.UNKNOWN, expr); } public ThrowStmt(Range range, final Expression expr) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TryStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TryStmt.java index 4688454b4..5052a3cf3 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TryStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TryStmt.java @@ -22,11 +22,12 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import com.github.javaparser.ast.expr.VariableDeclarationExpr; -import java.util.List; +import java.util.Optional; import static com.github.javaparser.utils.Utils.*; @@ -35,26 +36,33 @@ import static com.github.javaparser.utils.Utils.*; */ public final class TryStmt extends Statement { - private List<VariableDeclarationExpr> resources; + private NodeList<VariableDeclarationExpr> resources; private BlockStmt tryBlock; - private List<CatchClause> catchs; + private NodeList<CatchClause> catchs; - private BlockStmt finallyBlock; + private Optional<BlockStmt> finallyBlock; public TryStmt() { + this(Range.UNKNOWN, + new NodeList<>(), + new BlockStmt(), + new NodeList<>(), + none()); } - public TryStmt(final BlockStmt tryBlock, final List<CatchClause> catchs, - final BlockStmt finallyBlock) { - setTryBlock(tryBlock); - setCatchs(catchs); - setFinallyBlock(finallyBlock); + public TryStmt(final BlockStmt tryBlock, final NodeList<CatchClause> catchs, + final Optional<BlockStmt> finallyBlock) { + this(Range.UNKNOWN, + new NodeList<>(), + tryBlock, + catchs, + finallyBlock); } - public TryStmt(Range range, List<VariableDeclarationExpr> resources, - final BlockStmt tryBlock, final List<CatchClause> catchs, final BlockStmt finallyBlock) { + public TryStmt(Range range, NodeList<VariableDeclarationExpr> resources, + final BlockStmt tryBlock, final NodeList<CatchClause> catchs, final Optional<BlockStmt> finallyBlock) { super(range); setResources(resources); setTryBlock(tryBlock); @@ -72,12 +80,11 @@ public final class TryStmt extends Statement { v.visit(this, arg); } - public List<CatchClause> getCatchs() { - catchs = ensureNotNull(catchs); + public NodeList<CatchClause> getCatchs() { return catchs; } - public BlockStmt getFinallyBlock() { + public Optional<BlockStmt> getFinallyBlock() { return finallyBlock; } @@ -85,31 +92,30 @@ public final class TryStmt extends Statement { return tryBlock; } - public List<VariableDeclarationExpr> getResources() { - resources = ensureNotNull(resources); + public NodeList<VariableDeclarationExpr> getResources() { return resources; } - public TryStmt setCatchs(final List<CatchClause> catchs) { - this.catchs = catchs; + public TryStmt setCatchs(final NodeList<CatchClause> catchs) { + this.catchs = assertNotNull(catchs); setAsParentNodeOf(this.catchs); return this; } - public TryStmt setFinallyBlock(final BlockStmt finallyBlock) { - this.finallyBlock = finallyBlock; + public TryStmt setFinallyBlock(final Optional<BlockStmt> finallyBlock) { + this.finallyBlock = assertNotNull(finallyBlock); setAsParentNodeOf(this.finallyBlock); return this; } public TryStmt setTryBlock(final BlockStmt tryBlock) { - this.tryBlock = tryBlock; + this.tryBlock = assertNotNull(tryBlock); setAsParentNodeOf(this.tryBlock); return this; } - public TryStmt setResources(List<VariableDeclarationExpr> resources) { - this.resources = resources; + public TryStmt setResources(NodeList<VariableDeclarationExpr> resources) { + this.resources = assertNotNull(resources); setAsParentNodeOf(this.resources); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TypeDeclarationStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TypeDeclarationStmt.java index a9f83bf78..f42e679c7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TypeDeclarationStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/TypeDeclarationStmt.java @@ -22,10 +22,13 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.body.EmptyTypeDeclaration; import com.github.javaparser.ast.body.TypeDeclaration; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * @author Julio Vilmar Gesser */ @@ -34,10 +37,11 @@ public final class TypeDeclarationStmt extends Statement { private TypeDeclaration typeDecl; public TypeDeclarationStmt() { + this(Range.UNKNOWN, new EmptyTypeDeclaration()); } public TypeDeclarationStmt(final TypeDeclaration typeDecl) { - setTypeDeclaration(typeDecl); + this(Range.UNKNOWN, typeDecl); } public TypeDeclarationStmt(Range range, final TypeDeclaration typeDecl) { @@ -58,7 +62,7 @@ public final class TypeDeclarationStmt extends Statement { } public TypeDeclarationStmt setTypeDeclaration(final TypeDeclaration typeDecl) { - this.typeDecl = typeDecl; + this.typeDecl = assertNotNull(typeDecl); setAsParentNodeOf(this.typeDecl); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/WhileStmt.java b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/WhileStmt.java index b843494a4..f96f356b0 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/WhileStmt.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/stmt/WhileStmt.java @@ -22,6 +22,7 @@ package com.github.javaparser.ast.stmt; import com.github.javaparser.Range; +import com.github.javaparser.ast.expr.BooleanLiteralExpr; import com.github.javaparser.ast.expr.Expression; import com.github.javaparser.ast.nodeTypes.NodeWithBody; import com.github.javaparser.ast.visitor.GenericVisitor; @@ -37,11 +38,11 @@ public final class WhileStmt extends Statement implements NodeWithBody<WhileStmt private Statement body; public WhileStmt() { + this(Range.UNKNOWN, new BooleanLiteralExpr(), new EmptyStmt()); } public WhileStmt(final Expression condition, final Statement body) { - setCondition(condition); - setBody(body); + this(Range.UNKNOWN, condition, body); } public WhileStmt(Range range, final Expression condition, final Statement body) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/ArrayType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/ArrayType.java index babf2a5d7..8c741df6a 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/ArrayType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/ArrayType.java @@ -2,15 +2,14 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; import com.github.javaparser.ast.ArrayBracketPair; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import com.github.javaparser.utils.Pair; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; +import static com.github.javaparser.ast.NodeList.*; /** * To indicate that a type is an array, it gets wrapped in an ArrayType for every array level it has. @@ -19,12 +18,12 @@ import java.util.List; public class ArrayType extends ReferenceType<ArrayType> implements NodeWithAnnotations<ArrayType> { private Type componentType; - public ArrayType(Type componentType, List<AnnotationExpr> annotations) { + public ArrayType(Type componentType, NodeList<AnnotationExpr> annotations) { setComponentType(componentType); setAnnotations(annotations); } - public ArrayType(Range range, Type componentType, List<AnnotationExpr> annotations) { + public ArrayType(Range range, Type componentType, NodeList<AnnotationExpr> annotations) { super(range); setComponentType(componentType); setAnnotations(annotations); @@ -53,9 +52,9 @@ public class ArrayType extends ReferenceType<ArrayType> implements NodeWithAnnot * The type gets wrapped in ArrayTypes so that the outermost ArrayType corresponds to the rightmost ArrayBracketPair. */ @SafeVarargs - public static Type wrapInArrayTypes(Type type, List<ArrayBracketPair>... arrayBracketPairLists) { + public static Type wrapInArrayTypes(Type type, NodeList<ArrayBracketPair>... arrayBracketPairLists) { for (int i = arrayBracketPairLists.length - 1; i >= 0; i--) { - final List<ArrayBracketPair> arrayBracketPairList = arrayBracketPairLists[i]; + final NodeList<ArrayBracketPair> arrayBracketPairList = arrayBracketPairLists[i]; if (arrayBracketPairList != null) { for (int j = arrayBracketPairList.size() - 1; j >= 0; j--) { type = new ArrayType(type, arrayBracketPairList.get(j).getAnnotations()); @@ -70,8 +69,8 @@ public class ArrayType extends ReferenceType<ArrayType> implements NodeWithAnnot * * @return a pair of the element type, and the unwrapped ArrayTypes, if any. */ - public static Pair<Type, List<ArrayBracketPair>> unwrapArrayTypes(Type type) { - final List<ArrayBracketPair> arrayBracketPairs = new ArrayList<>(); + public static Pair<Type, NodeList<ArrayBracketPair>> unwrapArrayTypes(Type type) { + final NodeList<ArrayBracketPair> arrayBracketPairs = new NodeList<>(); while (type instanceof ArrayType) { ArrayType arrayType = (ArrayType) type; arrayBracketPairs.add(new ArrayBracketPair(Range.UNKNOWN, arrayType.getAnnotations())); @@ -81,6 +80,6 @@ public class ArrayType extends ReferenceType<ArrayType> implements NodeWithAnnot } public static ArrayType arrayOf(Type type, AnnotationExpr... annotations) { - return new ArrayType(type, Arrays.asList(annotations)); + return new ArrayType(type, nodeList(annotations)); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/ClassOrInterfaceType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/ClassOrInterfaceType.java index ac308940d..f05ee6448 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/ClassOrInterfaceType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/ClassOrInterfaceType.java @@ -22,6 +22,7 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.nodeTypes.NodeWithName; import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; @@ -29,8 +30,10 @@ import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import java.util.List; +import java.util.Optional; -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; /** * @author Julio Vilmar Gesser @@ -40,25 +43,34 @@ public final class ClassOrInterfaceType extends ReferenceType<ClassOrInterfaceTy NodeWithAnnotations<ClassOrInterfaceType>, NodeWithTypeArguments<ClassOrInterfaceType> { - private ClassOrInterfaceType scope; + private Optional<ClassOrInterfaceType> scope; private String name; - private List<Type<?>> typeArguments; + private Optional<NodeList<Type<?>>> typeArguments; public ClassOrInterfaceType() { + this(Range.UNKNOWN, + none(), + "empty", + none()); } public ClassOrInterfaceType(final String name) { - setName(name); + this(Range.UNKNOWN, + none(), + name, + none()); } - public ClassOrInterfaceType(final ClassOrInterfaceType scope, final String name) { - setScope(scope); - setName(name); + public ClassOrInterfaceType(final Optional<ClassOrInterfaceType> scope, final String name) { + this(Range.UNKNOWN, + scope, + name, + none()); } - public ClassOrInterfaceType(final Range range, final ClassOrInterfaceType scope, final String name, final List<Type<?>> typeArguments) { + public ClassOrInterfaceType(final Range range, final Optional<ClassOrInterfaceType> scope, final String name, final Optional<NodeList<Type<?>>> typeArguments) { super(range); setScope(scope); setName(name); @@ -78,7 +90,7 @@ public final class ClassOrInterfaceType extends ReferenceType<ClassOrInterfaceTy return name; } - public ClassOrInterfaceType getScope() { + public Optional<ClassOrInterfaceType> getScope() { return scope; } @@ -99,20 +111,20 @@ public final class ClassOrInterfaceType extends ReferenceType<ClassOrInterfaceTy return this; } - public ClassOrInterfaceType setScope(final ClassOrInterfaceType scope) { - this.scope = scope; + public ClassOrInterfaceType setScope(final Optional<ClassOrInterfaceType> scope) { + this.scope = assertNotNull(scope); setAsParentNodeOf(this.scope); return this; } @Override - public List<Type<?>> getTypeArguments() { + public Optional<NodeList<Type<?>>> getTypeArguments() { return typeArguments; } @Override - public ClassOrInterfaceType setTypeArguments(final List<Type<?>> types) { - this.typeArguments = types; + public ClassOrInterfaceType setTypeArguments(final Optional<NodeList<Type<?>>> types) { + this.typeArguments = assertNotNull(types); setAsParentNodeOf(this.typeArguments); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/IntersectionType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/IntersectionType.java index 029d46537..092138da1 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/IntersectionType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/IntersectionType.java @@ -1,35 +1,37 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import java.util.List; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * Represents a set of types. A given value of this type has to be assignable to at all of the element types. * As of Java 8 it is used in casts or while expressing bounds for generic types. * * For example: - * public class A>T extends Serializable & Cloneable< { } + * <code>public class A<T extends Serializable & Cloneable> { }</code> * * Or: - * void foo((Serializable & Cloneable)myObject); + * <code>void foo((Serializable & Cloneable)myObject);</code> * * @since 3.0.0 */ public class IntersectionType extends Type<IntersectionType> implements NodeWithAnnotations<IntersectionType> { - private List<ReferenceType> elements; + private NodeList<ReferenceType<?>> elements; - public IntersectionType(Range range, List<ReferenceType> elements) { - super(range); - setElements(elements); + public IntersectionType(NodeList<ReferenceType<?>> elements) { + this(Range.UNKNOWN, elements); } - public IntersectionType(List<ReferenceType> elements) { - super(); + public IntersectionType(Range range, NodeList<ReferenceType<?>> elements) { + super(range, new NodeList<>()); setElements(elements); } @@ -43,17 +45,12 @@ public class IntersectionType extends Type<IntersectionType> implements NodeWith v.visit(this, arg); } - public List<ReferenceType> getElements() { + public NodeList<ReferenceType<?>> getElements() { return elements; } - public IntersectionType setElements(List<ReferenceType> elements) { - if (this.elements != null) { - for (ReferenceType element : elements){ - element.setParentNode(null); - } - } - this.elements = elements; + public IntersectionType setElements(NodeList<ReferenceType<?>> elements) { + this.elements = assertNotNull(elements); setAsParentNodeOf(this.elements); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/PrimitiveType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/PrimitiveType.java index 29299a425..cd50418fb 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/PrimitiveType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/PrimitiveType.java @@ -22,12 +22,11 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import static com.github.javaparser.utils.Utils.ensureNotNull; - import java.util.HashMap; /** @@ -82,14 +81,15 @@ public final class PrimitiveType extends Type<PrimitiveType> implements NodeWith private Primitive type; public PrimitiveType() { + this(Range.UNKNOWN, Primitive.Int); } public PrimitiveType(final Primitive type) { - this.type = type; + this(Range.UNKNOWN, type); } public PrimitiveType(Range range, final Primitive type) { - super(range); + super(range, new NodeList<>()); setType(type); } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/ReferenceType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/ReferenceType.java index 1a4666b4f..e0419195e 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/ReferenceType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/ReferenceType.java @@ -22,6 +22,7 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; /** * @author Julio Vilmar Gesser @@ -29,9 +30,10 @@ import com.github.javaparser.Range; public abstract class ReferenceType<T extends ReferenceType> extends Type<T> { public ReferenceType() { + this(Range.UNKNOWN); } public ReferenceType(final Range range) { - super(range); + super(range, new NodeList<>()); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/Type.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/Type.java index 6c043557a..147a83d11 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/Type.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/Type.java @@ -23,10 +23,8 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; -import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; - -import java.util.List; import static com.github.javaparser.utils.Utils.*; @@ -35,33 +33,20 @@ import static com.github.javaparser.utils.Utils.*; */ public abstract class Type<T extends Type> extends Node { - private List<AnnotationExpr> annotations; - - public Type() { - } - - public Type(List<AnnotationExpr> annotation){ - this.annotations = annotation; - } + private NodeList<AnnotationExpr> annotations = new NodeList<>(); - public Type(Range range) { - super(range); - } - - public Type(Range range, List<AnnotationExpr> annotations) { + public Type(Range range, NodeList<AnnotationExpr> annotations) { super(range); setAnnotations(annotations); } - public List<AnnotationExpr> getAnnotations() { - annotations = ensureNotNull(annotations); + public NodeList<AnnotationExpr> getAnnotations() { return annotations; } - public T setAnnotations(List<AnnotationExpr> annotations) { + public T setAnnotations(NodeList<AnnotationExpr> annotations) { + this.annotations = assertNotNull(annotations); setAsParentNodeOf(annotations); - this.annotations = annotations; return (T) this; } - } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/TypeParameter.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/TypeParameter.java index bfec9c936..271a7e73e 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/TypeParameter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/TypeParameter.java @@ -22,15 +22,13 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; -import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.nodeTypes.NodeWithName; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - -import static com.github.javaparser.utils.Utils.ensureNotNull; +import static com.github.javaparser.utils.Utils.assertNotNull; /** * <p> @@ -48,26 +46,34 @@ public final class TypeParameter extends ReferenceType<TypeParameter> implements private String name; - private List<AnnotationExpr> annotations; + private NodeList<AnnotationExpr> annotations; - private List<ClassOrInterfaceType> typeBound; + private NodeList<ClassOrInterfaceType> typeBound; public TypeParameter() { + this(Range.UNKNOWN, + "empty", + new NodeList<>(), + new NodeList<>()); } - public TypeParameter(final String name, final List<ClassOrInterfaceType> typeBound) { - setName(name); - setTypeBound(typeBound); + public TypeParameter(final String name, final NodeList<ClassOrInterfaceType> typeBound) { + this(Range.UNKNOWN, + name, + typeBound, + new NodeList<>()); } - public TypeParameter(Range range, final String name, final List<ClassOrInterfaceType> typeBound) { - super(range); - setName(name); - setTypeBound(typeBound); + public TypeParameter(Range range, final String name, final NodeList<ClassOrInterfaceType> typeBound) { + this(range, + name, + typeBound, + new NodeList<>()); } - public TypeParameter(Range range, String name, List<ClassOrInterfaceType> typeBound, List<AnnotationExpr> annotations) { - this(range, name, typeBound); + public TypeParameter(Range range, String name, NodeList<ClassOrInterfaceType> typeBound, NodeList<AnnotationExpr> annotations) { + super(range); + setName(name); setTypeBound(typeBound); setAnnotations(annotations); } @@ -96,42 +102,30 @@ public final class TypeParameter extends ReferenceType<TypeParameter> implements * * @return list of types that this paramente extends or <code>null</code> */ - public List<ClassOrInterfaceType> getTypeBound() { - typeBound = ensureNotNull(typeBound); + public NodeList<ClassOrInterfaceType> getTypeBound() { return typeBound; } - /** - * Sets the name of this type parameter. - * - * @param name - * the name to set - */ @Override public TypeParameter setName(final String name) { this.name = name; return this; } - /** - * Sets the list o types. - * - * @param typeBound - * the typeBound to set - */ - public TypeParameter setTypeBound(final List<ClassOrInterfaceType> typeBound) { - this.typeBound = typeBound; + public TypeParameter setTypeBound(final NodeList<ClassOrInterfaceType> typeBound) { + this.typeBound = assertNotNull(typeBound); setAsParentNodeOf(typeBound); return this; } - public List<AnnotationExpr> getAnnotations() { - annotations = ensureNotNull(annotations); + @Override + public NodeList<AnnotationExpr> getAnnotations() { return annotations; } - public TypeParameter setAnnotations(List<AnnotationExpr> annotations) { - this.annotations = annotations; + @Override + public TypeParameter setAnnotations(NodeList<AnnotationExpr> annotations) { + this.annotations = assertNotNull(annotations); setAsParentNodeOf(this.annotations); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnionType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnionType.java index 74894af0f..322e100c7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnionType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnionType.java @@ -1,41 +1,38 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; import java.util.List; +import static com.github.javaparser.utils.Utils.assertNotNull; + /** * Represents a set of types. A given value of this type has to be assignable to at least one of the element types. * As of Java 8 it is only used in catch clauses. */ public class UnionType extends Type<UnionType> implements NodeWithAnnotations<UnionType> { - private List<ReferenceType> elements; + private NodeList<ReferenceType<?>> elements; - public UnionType(Range range, List<ReferenceType> elements) { - super(range); + public UnionType(Range range, NodeList<ReferenceType<?>> elements) { + super(range, new NodeList<>()); setElements(elements); } - public UnionType(List<ReferenceType> elements) { - super(); - setElements(elements); + public UnionType(NodeList<ReferenceType<?>> elements) { + this(Range.UNKNOWN, elements); } - public List<ReferenceType> getElements() { + public NodeList<ReferenceType<?>> getElements() { return elements; } - public UnionType setElements(List<ReferenceType> elements) { - if (this.elements != null) { - for (ReferenceType element : elements){ - element.setParentNode(null); - } - } - this.elements = elements; + public UnionType setElements(NodeList<ReferenceType<?>> elements) { + this.elements = assertNotNull(elements); setAsParentNodeOf(this.elements); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnknownType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnknownType.java index b76c5962c..54236b175 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnknownType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/UnknownType.java @@ -21,12 +21,12 @@ package com.github.javaparser.ast.type; +import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; -import java.util.List; - /** * An unknown parameter type object. It plays the role of a null object for * lambda parameters that have no explicit type declared. As such, it has no @@ -37,6 +37,7 @@ import java.util.List; public final class UnknownType extends Type<UnknownType> { public UnknownType() { + super(Range.UNKNOWN, new NodeList<>()); } @Override @@ -50,13 +51,10 @@ public final class UnknownType extends Type<UnknownType> { } @Override - public List<AnnotationExpr> getAnnotations() { - throw new IllegalStateException("Inferred lambda types cannot be annotated."); + public UnknownType setAnnotations(NodeList<AnnotationExpr> annotations) { + if (annotations.size() > 0) { + throw new IllegalStateException("Inferred lambda types cannot be annotated."); + } + return this; } - - @Override - public UnknownType setAnnotations(List<AnnotationExpr> annotations) { - throw new IllegalStateException("Inferred lambda types cannot be annotated."); - } - } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/VoidType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/VoidType.java index d5f7273cb..fbc855202 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/VoidType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/VoidType.java @@ -22,6 +22,7 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; @@ -34,10 +35,11 @@ public final class VoidType extends Type<VoidType> implements NodeWithAnnotation public static final VoidType VOID_TYPE = new VoidType(); public VoidType() { + this(Range.UNKNOWN); } public VoidType(Range range) { - super(range); + super(range, new NodeList<>()); } @Override public <R, A> R accept(final GenericVisitor<R, A> v, final A arg) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/type/WildcardType.java b/javaparser-core/src/main/java/com/github/javaparser/ast/type/WildcardType.java index d1e49bc0b..46f3fae25 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/type/WildcardType.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/type/WildcardType.java @@ -22,34 +22,41 @@ package com.github.javaparser.ast.type; import com.github.javaparser.Range; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.visitor.GenericVisitor; import com.github.javaparser.ast.visitor.VoidVisitor; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.assertNotNull; +import static com.github.javaparser.utils.Utils.none; +import static com.github.javaparser.utils.Utils.some; + /** * @author Julio Vilmar Gesser */ public final class WildcardType extends Type<WildcardType> implements NodeWithAnnotations<WildcardType> { - private ReferenceType ext; + private Optional<ReferenceType<?>> ext; - private ReferenceType sup; + private Optional<ReferenceType<?>> sup; public WildcardType() { + this(Range.UNKNOWN, none(), none()); } - public WildcardType(final ReferenceType ext) { - setExtends(ext); + public WildcardType(final ReferenceType<?> ext) { + this(Range.UNKNOWN, some(ext), none()); } - public WildcardType(final ReferenceType ext, final ReferenceType sup) { - setExtends(ext); - setSuper(sup); + public WildcardType(final Optional<ReferenceType<?>> ext, final Optional<ReferenceType<?>> sup) { + this(Range.UNKNOWN, ext, sup); } public WildcardType(final Range range, - final ReferenceType ext, final ReferenceType sup) { - super(range); + final Optional<ReferenceType<?>> ext, final Optional<ReferenceType<?>> sup) { + super(range, new NodeList<>()); setExtends(ext); setSuper(sup); } @@ -62,22 +69,22 @@ public final class WildcardType extends Type<WildcardType> implements NodeWithAn v.visit(this, arg); } - public ReferenceType getExtends() { + public Optional<ReferenceType<?>> getExtends() { return ext; } - public ReferenceType getSuper() { + public Optional<ReferenceType<?>> getSuper() { return sup; } - public WildcardType setExtends(final ReferenceType ext) { - this.ext = ext; + public WildcardType setExtends(final Optional<ReferenceType<?>> ext) { + this.ext = assertNotNull(ext); setAsParentNodeOf(this.ext); return this; } - public WildcardType setSuper(final ReferenceType sup) { - this.sup = sup; + public WildcardType setSuper(final Optional<ReferenceType<?>> sup) { + this.sup = assertNotNull(sup); setAsParentNodeOf(this.sup); return this; } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/CloneVisitor.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/CloneVisitor.java index e3ca153c4..1c5ebd4c2 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/CloneVisitor.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/CloneVisitor.java @@ -21,100 +21,28 @@ package com.github.javaparser.ast.visitor; -import java.util.ArrayList; -import java.util.List; - import com.github.javaparser.ast.*; -import com.github.javaparser.ast.imports.*; -import com.github.javaparser.ast.type.TypeParameter; -import com.github.javaparser.ast.body.AnnotationDeclaration; -import com.github.javaparser.ast.body.AnnotationMemberDeclaration; -import com.github.javaparser.ast.body.BodyDeclaration; -import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; -import com.github.javaparser.ast.body.ConstructorDeclaration; -import com.github.javaparser.ast.body.EmptyMemberDeclaration; -import com.github.javaparser.ast.body.EmptyTypeDeclaration; -import com.github.javaparser.ast.body.EnumConstantDeclaration; -import com.github.javaparser.ast.body.EnumDeclaration; -import com.github.javaparser.ast.body.FieldDeclaration; -import com.github.javaparser.ast.body.InitializerDeclaration; -import com.github.javaparser.ast.body.MethodDeclaration; -import com.github.javaparser.ast.body.Parameter; -import com.github.javaparser.ast.body.TypeDeclaration; -import com.github.javaparser.ast.body.VariableDeclarator; -import com.github.javaparser.ast.body.VariableDeclaratorId; +import com.github.javaparser.ast.body.*; import com.github.javaparser.ast.comments.BlockComment; import com.github.javaparser.ast.comments.Comment; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.comments.LineComment; -import com.github.javaparser.ast.expr.AnnotationExpr; -import com.github.javaparser.ast.expr.ArrayAccessExpr; -import com.github.javaparser.ast.expr.ArrayCreationExpr; -import com.github.javaparser.ast.expr.ArrayInitializerExpr; -import com.github.javaparser.ast.expr.AssignExpr; -import com.github.javaparser.ast.expr.BinaryExpr; -import com.github.javaparser.ast.expr.BooleanLiteralExpr; -import com.github.javaparser.ast.expr.CastExpr; -import com.github.javaparser.ast.expr.CharLiteralExpr; -import com.github.javaparser.ast.expr.ClassExpr; -import com.github.javaparser.ast.expr.ConditionalExpr; -import com.github.javaparser.ast.expr.DoubleLiteralExpr; -import com.github.javaparser.ast.expr.EnclosedExpr; -import com.github.javaparser.ast.expr.Expression; -import com.github.javaparser.ast.expr.FieldAccessExpr; -import com.github.javaparser.ast.expr.InstanceOfExpr; -import com.github.javaparser.ast.expr.IntegerLiteralExpr; -import com.github.javaparser.ast.expr.IntegerLiteralMinValueExpr; -import com.github.javaparser.ast.expr.LambdaExpr; -import com.github.javaparser.ast.expr.LongLiteralExpr; -import com.github.javaparser.ast.expr.LongLiteralMinValueExpr; -import com.github.javaparser.ast.expr.MarkerAnnotationExpr; -import com.github.javaparser.ast.expr.MemberValuePair; -import com.github.javaparser.ast.expr.MethodCallExpr; -import com.github.javaparser.ast.expr.MethodReferenceExpr; -import com.github.javaparser.ast.expr.NameExpr; -import com.github.javaparser.ast.expr.NormalAnnotationExpr; -import com.github.javaparser.ast.expr.NullLiteralExpr; -import com.github.javaparser.ast.expr.ObjectCreationExpr; -import com.github.javaparser.ast.expr.QualifiedNameExpr; -import com.github.javaparser.ast.expr.SingleMemberAnnotationExpr; -import com.github.javaparser.ast.expr.StringLiteralExpr; -import com.github.javaparser.ast.expr.SuperExpr; -import com.github.javaparser.ast.expr.ThisExpr; -import com.github.javaparser.ast.expr.TypeExpr; -import com.github.javaparser.ast.expr.UnaryExpr; -import com.github.javaparser.ast.expr.VariableDeclarationExpr; -import com.github.javaparser.ast.stmt.AssertStmt; -import com.github.javaparser.ast.stmt.BlockStmt; -import com.github.javaparser.ast.stmt.BreakStmt; -import com.github.javaparser.ast.stmt.CatchClause; -import com.github.javaparser.ast.stmt.ContinueStmt; -import com.github.javaparser.ast.stmt.DoStmt; -import com.github.javaparser.ast.stmt.EmptyStmt; -import com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt; -import com.github.javaparser.ast.stmt.ExpressionStmt; -import com.github.javaparser.ast.stmt.ForStmt; -import com.github.javaparser.ast.stmt.ForeachStmt; -import com.github.javaparser.ast.stmt.IfStmt; -import com.github.javaparser.ast.stmt.LabeledStmt; -import com.github.javaparser.ast.stmt.ReturnStmt; -import com.github.javaparser.ast.stmt.Statement; -import com.github.javaparser.ast.stmt.SwitchEntryStmt; -import com.github.javaparser.ast.stmt.SwitchStmt; -import com.github.javaparser.ast.stmt.SynchronizedStmt; -import com.github.javaparser.ast.stmt.ThrowStmt; -import com.github.javaparser.ast.stmt.TryStmt; -import com.github.javaparser.ast.stmt.TypeDeclarationStmt; -import com.github.javaparser.ast.stmt.WhileStmt; +import com.github.javaparser.ast.expr.*; +import com.github.javaparser.ast.imports.*; +import com.github.javaparser.ast.stmt.*; import com.github.javaparser.ast.type.*; +import java.util.Optional; + +import static com.github.javaparser.utils.Utils.option; + public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(CompilationUnit _n, Object _arg) { - PackageDeclaration package_ = cloneNodes(_n.getPackage(), _arg); - List<ImportDeclaration> imports = visit(_n.getImports(), _arg); - List<TypeDeclaration<?>> types = visit(_n.getTypes(), _arg); + Optional<PackageDeclaration> package_ = cloneNode(_n.getPackage(), _arg); + NodeList<ImportDeclaration> imports = cloneList(_n.getImports(), _arg); + NodeList<TypeDeclaration<?>> types = cloneList(_n.getTypes(), _arg); return new CompilationUnit( _n.getRange(), @@ -124,9 +52,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(PackageDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - NameExpr name = cloneNodes(_n.getName(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NameExpr name = cloneNode(_n.getName(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); PackageDeclaration r = new PackageDeclaration( _n.getRange(), @@ -138,13 +66,12 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(TypeParameter _n, Object _arg) { - List<ClassOrInterfaceType> typeBound = visit(_n.getTypeBound(), _arg); - - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); + NodeList<ClassOrInterfaceType> typeBound = cloneList(_n.getTypeBound(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); TypeParameter r = new TypeParameter(_n.getRange(), _n.getName(), typeBound, annotations); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); r.setComment(comment); return r; } @@ -161,16 +88,17 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ClassOrInterfaceDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - List<TypeParameter> typeParameters = visit(_n.getTypeParameters(), _arg); - List<ClassOrInterfaceType> extendsList = visit(_n.getExtends(), _arg); - List<ClassOrInterfaceType> implementsList = visit(_n.getImplements(), _arg); - List<BodyDeclaration<?>> members = visit(_n.getMembers(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NodeList<TypeParameter> typeParameters = cloneList(_n.getTypeParameters(), _arg); + NodeList<ClassOrInterfaceType> extendsList = cloneList(_n.getExtends(), _arg); + NodeList<ClassOrInterfaceType> implementsList = cloneList(_n.getImplements(), _arg); + NodeList<BodyDeclaration<?>> members = cloneList(_n.getMembers(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NameExpr nameExpr_ = cloneNode(_n.getNameExpr(), _arg); - ClassOrInterfaceDeclaration r = new ClassOrInterfaceDeclaration( + ClassOrInterfaceDeclaration r = new ClassOrInterfaceDeclaration( _n.getRange(), - _n.getModifiers(), annotations, _n.isInterface(), _n.getName(), typeParameters, extendsList, implementsList, members + _n.getModifiers(), annotations, _n.isInterface(), nameExpr_, typeParameters, extendsList, implementsList, members ); r.setComment(comment); return r; @@ -178,15 +106,16 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(EnumDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - List<ClassOrInterfaceType> implementsList = visit(_n.getImplements(), _arg); - List<EnumConstantDeclaration> entries = visit(_n.getEntries(), _arg); - List<BodyDeclaration<?>> members = visit(_n.getMembers(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NodeList<ClassOrInterfaceType> implementsList = cloneList(_n.getImplements(), _arg); + NodeList<EnumConstantDeclaration> entries = cloneList(_n.getEntries(), _arg); + NodeList<BodyDeclaration<?>> members = cloneList(_n.getMembers(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NameExpr nameExpr_ = cloneNode(_n.getNameExpr(), _arg); EnumDeclaration r = new EnumDeclaration( _n.getRange(), - _n.getModifiers(), annotations, _n.getName(), implementsList, entries, members + _n.getModifiers(), annotations, nameExpr_, implementsList, entries, members ); r.setComment(comment); return r; @@ -194,7 +123,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(EmptyTypeDeclaration _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); EmptyTypeDeclaration r = new EmptyTypeDeclaration( _n.getRange() @@ -205,10 +134,10 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(EnumConstantDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - List<Expression> args = visit(_n.getArgs(), _arg); - List<BodyDeclaration<?>> classBody = visit(_n.getClassBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NodeList<Expression> args = cloneList(_n.getArgs(), _arg); + NodeList<BodyDeclaration<?>> classBody = cloneList(_n.getClassBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); EnumConstantDeclaration r = new EnumConstantDeclaration( _n.getRange(), @@ -220,13 +149,14 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(AnnotationDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - List<BodyDeclaration<?>> members = visit(_n.getMembers(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NodeList<BodyDeclaration<?>> members = cloneList(_n.getMembers(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NameExpr nameExpr_ = cloneNode(_n.getNameExpr(), _arg); AnnotationDeclaration r = new AnnotationDeclaration( _n.getRange(), - _n.getModifiers(), annotations, _n.getName(), members + _n.getModifiers(), annotations, nameExpr_, members ); r.setComment(comment); return r; @@ -234,10 +164,10 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(AnnotationMemberDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - Type<?> type_ = cloneNodes(_n.getType(), _arg); - Expression defaultValue = cloneNodes(_n.getDefaultValue(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + Type<?> type_ = cloneNode(_n.getType(), _arg); + Optional<Expression> defaultValue = cloneNode(_n.getDefaultValue(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); AnnotationMemberDeclaration r = new AnnotationMemberDeclaration( _n.getRange(), @@ -249,11 +179,11 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(FieldDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations_ = visit(_n.getAnnotations(), _arg); - Type<?> elementType_ = cloneNodes(_n.getElementType(), _arg); - List<VariableDeclarator> variables_ = visit(_n.getVariables(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); - List<ArrayBracketPair> arrayBracketPairsAfterType_ = visit(_n.getArrayBracketPairsAfterElementType(), _arg); + NodeList<AnnotationExpr> annotations_ = cloneList(_n.getAnnotations(), _arg); + Type<?> elementType_ = cloneNode(_n.getElementType(), _arg); + NodeList<VariableDeclarator> variables_ = cloneList(_n.getVariables(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NodeList<ArrayBracketPair> arrayBracketPairsAfterType_ = cloneList(_n.getArrayBracketPairsAfterElementType(), _arg); FieldDeclaration r = new FieldDeclaration( _n.getRange(), @@ -270,9 +200,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(VariableDeclarator _n, Object _arg) { - VariableDeclaratorId id = cloneNodes(_n.getId(), _arg); - Expression init = cloneNodes(_n.getInit(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + VariableDeclaratorId id = cloneNode(_n.getId(), _arg); + Optional<Expression> init = cloneNode(_n.getInit(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); VariableDeclarator r = new VariableDeclarator( _n.getRange(), @@ -284,8 +214,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(VariableDeclaratorId _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); - List<ArrayBracketPair> arrayBracketPairsAfterId_ = visit(_n.getArrayBracketPairsAfterId(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NodeList<ArrayBracketPair> arrayBracketPairsAfterId_ = cloneList(_n.getArrayBracketPairsAfterId(), _arg); VariableDeclaratorId r = new VariableDeclaratorId( _n.getRange(), @@ -298,16 +228,17 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ConstructorDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - List<TypeParameter> typeParameters = visit(_n.getTypeParameters(), _arg); - List<Parameter> parameters = visit(_n.getParameters(), _arg); - List<ReferenceType> throws_ = visit(_n.getThrows(), _arg); - BlockStmt block = cloneNodes(_n.getBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NodeList<TypeParameter> typeParameters = cloneList(_n.getTypeParameters(), _arg); + NodeList<Parameter> parameters= cloneList(_n.getParameters(), _arg); + NodeList<ReferenceType<?>> throws_ = cloneList(_n.getThrows(), _arg); + BlockStmt block = cloneNode(_n.getBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NameExpr nameExpr_ = cloneNode(_n.getNameExpr(), _arg); ConstructorDeclaration r = new ConstructorDeclaration( _n.getRange(), - _n.getModifiers(), annotations, typeParameters, _n.getName(), parameters, throws_, block + _n.getModifiers(), annotations, typeParameters, nameExpr_, parameters, throws_, block ); r.setComment(comment); return r; @@ -315,16 +246,16 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(MethodDeclaration _n, Object _arg) { - List<AnnotationExpr> annotations_ = visit(_n.getAnnotations(), _arg); - List<TypeParameter> typeParameters_ = visit(_n.getTypeParameters(), _arg); - Type<?> type_ = cloneNodes(_n.getElementType(), _arg); - NameExpr nameExpr_ = cloneNodes(_n.getNameExpr(), _arg); - List<Parameter> parameters_ = visit(_n.getParameters(), _arg); - List<ReferenceType> throws_ = visit(_n.getThrows(), _arg); - BlockStmt block_ = cloneNodes(_n.getBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); - List<ArrayBracketPair> arrayBracketPairsAfterElementType_ = visit(_n.getArrayBracketPairsAfterElementType(), _arg); - List<ArrayBracketPair> arrayBracketPairsAfterParameterList_ = visit(_n.getArrayBracketPairsAfterParameterList(), _arg); + NodeList<AnnotationExpr> annotations_ = cloneList(_n.getAnnotations(), _arg); + NodeList<TypeParameter> typeParameters_ = cloneList(_n.getTypeParameters(), _arg); + Type<?> type_ = cloneNode(_n.getElementType(), _arg); + NameExpr nameExpr_ = cloneNode(_n.getNameExpr(), _arg); + NodeList<Parameter> parameters_ = cloneList(_n.getParameters(), _arg); + NodeList<ReferenceType<?>> throws_ = cloneList(_n.getThrows(), _arg); + Optional<BlockStmt> block_ = cloneNode(_n.getBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NodeList<ArrayBracketPair> arrayBracketPairsAfterElementType_ = cloneList(_n.getArrayBracketPairsAfterElementType(), _arg); + NodeList<ArrayBracketPair> arrayBracketPairsAfterParameterList_ = cloneList(_n.getArrayBracketPairsAfterParameterList(), _arg); MethodDeclaration r = new MethodDeclaration( _n.getRange(), @@ -345,11 +276,11 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(Parameter _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - Type<?> type_ = cloneNodes(_n.getElementType(), _arg); - VariableDeclaratorId id = cloneNodes(_n.getId(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); - List<ArrayBracketPair> arrayBracketPairsAfterType_ = visit(_n.getArrayBracketPairsAfterElementType(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + Type<?> type_ = cloneNode(_n.getElementType(), _arg); + VariableDeclaratorId id = cloneNode(_n.getId(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NodeList<ArrayBracketPair> arrayBracketPairsAfterType_ = cloneList(_n.getArrayBracketPairsAfterElementType(), _arg); Parameter r = new Parameter( _n.getRange(), @@ -366,7 +297,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(EmptyMemberDeclaration _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); EmptyMemberDeclaration r = new EmptyMemberDeclaration( _n.getRange() @@ -377,8 +308,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(InitializerDeclaration _n, Object _arg) { - BlockStmt block = cloneNodes(_n.getBlock(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + BlockStmt block = cloneNode(_n.getBlock(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); InitializerDeclaration r = new InitializerDeclaration( _n.getRange(), @@ -390,7 +321,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(JavadocComment _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); JavadocComment r = new JavadocComment( _n.getRange(), _n.getContent() @@ -401,15 +332,15 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ClassOrInterfaceType _n, Object _arg) { - ClassOrInterfaceType scope = cloneNodes(_n.getScope(), _arg); - List<Type<?>> typeArguments_ = visit(_n.getTypeArguments(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<ClassOrInterfaceType> scope = cloneNode(_n.getScope(), _arg); + Optional<NodeList<Type<?>>> typeArguments = cloneList(_n.getTypeArguments(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ClassOrInterfaceType r = new ClassOrInterfaceType( _n.getRange(), scope, _n.getName(), - _n.getTypeArguments() + typeArguments ); r.setComment(comment); return r; @@ -417,8 +348,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(PrimitiveType _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); PrimitiveType r = new PrimitiveType( _n.getRange(), @@ -431,34 +362,34 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ArrayType _n, Object _arg) { - List<AnnotationExpr> ann = visit(_n.getAnnotations(), _arg); - Type<?> type_ = cloneNodes(_n.getComponentType(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + Type<?> type_ = cloneNode(_n.getComponentType(), _arg); - ArrayType r = new ArrayType(_n.getRange(), type_, ann); - Comment comment = cloneNodes(_n.getComment(), _arg); + ArrayType r = new ArrayType(_n.getRange(), type_, annotations); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); r.setComment(comment); return r; } @Override public Node visit(ArrayCreationLevel _n, Object _arg) { - List<AnnotationExpr> ann = visit(_n.getAnnotations(), _arg); - Expression dimension_ = cloneNodes(_n.getDimension(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + Optional<Expression> dimension_ = cloneNode(_n.getDimension(), _arg); - ArrayCreationLevel r = new ArrayCreationLevel(_n.getRange(), dimension_, ann); + ArrayCreationLevel r = new ArrayCreationLevel(_n.getRange(), dimension_, annotations); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); r.setComment(comment); return r; } @Override public Node visit(IntersectionType _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - List<ReferenceType> elements = visit(_n.getElements(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NodeList<ReferenceType<?>> elements= cloneList(_n.getElements(), _arg); IntersectionType r = new IntersectionType(_n.getRange(), elements); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); r.setComment(comment); r.setAnnotations(annotations); return r; @@ -466,12 +397,11 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(UnionType _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - List<ReferenceType> elements = visit(_n.getElements(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + NodeList<ReferenceType<?>> elements= cloneList(_n.getElements(), _arg); - UnionType r = new UnionType(_n.getRange(), - elements); - Comment comment = cloneNodes(_n.getComment(), _arg); + UnionType r = new UnionType(_n.getRange(), elements); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); r.setComment(comment); r.setAnnotations(annotations); return r; @@ -479,8 +409,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(VoidType _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); VoidType r = new VoidType(_n.getRange()); r.setAnnotations(annotations); @@ -490,10 +420,10 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(WildcardType _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - ReferenceType ext = cloneNodes(_n.getExtends(), _arg); - ReferenceType sup = cloneNodes(_n.getSuper(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + Optional<ReferenceType<?>> ext = cloneNode(_n.getExtends(), _arg); + Optional<ReferenceType<?>> sup = cloneNode(_n.getSuper(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); WildcardType r = new WildcardType( _n.getRange(), @@ -506,7 +436,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(UnknownType _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); UnknownType r = new UnknownType(); r.setComment(comment); @@ -515,9 +445,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ArrayAccessExpr _n, Object _arg) { - Expression name = cloneNodes(_n.getName(), _arg); - Expression index = cloneNodes(_n.getIndex(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression name = cloneNode(_n.getName(), _arg); + Expression index = cloneNode(_n.getIndex(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ArrayAccessExpr r = new ArrayAccessExpr( _n.getRange(), @@ -529,21 +459,21 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ArrayCreationExpr _n, Object _arg) { - Type<?> type_ = cloneNodes(_n.getType(), _arg); - List<ArrayCreationLevel> levels_ = visit(_n.getLevels(), _arg); - ArrayInitializerExpr initializer_ = cloneNodes(_n.getInitializer(), _arg); + Type<?> type_ = cloneNode(_n.getElementType(), _arg); + NodeList<ArrayCreationLevel> levels_ = cloneList(_n.getLevels(), _arg); + Optional<ArrayInitializerExpr> initializer_ = cloneNode(_n.getInitializer(), _arg); ArrayCreationExpr r = new ArrayCreationExpr(_n.getRange(), type_, levels_, initializer_); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); r.setComment(comment); return r; } @Override public Node visit(ArrayInitializerExpr _n, Object _arg) { - List<Expression> values = visit(_n.getValues(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<Expression> values = cloneList(_n.getValues(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ArrayInitializerExpr r = new ArrayInitializerExpr( _n.getRange(), @@ -555,9 +485,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(AssignExpr _n, Object _arg) { - Expression target = cloneNodes(_n.getTarget(), _arg); - Expression value = cloneNodes(_n.getValue(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression target = cloneNode(_n.getTarget(), _arg); + Expression value = cloneNode(_n.getValue(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); AssignExpr r = new AssignExpr( _n.getRange(), @@ -568,9 +498,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(BinaryExpr _n, Object _arg) { - Expression left = cloneNodes(_n.getLeft(), _arg); - Expression right = cloneNodes(_n.getRight(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression left = cloneNode(_n.getLeft(), _arg); + Expression right = cloneNode(_n.getRight(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); BinaryExpr r = new BinaryExpr( _n.getRange(), @@ -582,9 +512,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(CastExpr _n, Object _arg) { - Type<?> type_ = cloneNodes(_n.getType(), _arg); - Expression expr = cloneNodes(_n.getExpr(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Type<?> type_ = cloneNode(_n.getType(), _arg); + Expression expr = cloneNode(_n.getExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); CastExpr r = new CastExpr( _n.getRange(), @@ -596,8 +526,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ClassExpr _n, Object _arg) { - Type<?> type_ = cloneNodes(_n.getType(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Type<?> type_ = cloneNode(_n.getType(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ClassExpr r = new ClassExpr( _n.getRange(), @@ -609,10 +539,10 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ConditionalExpr _n, Object _arg) { - Expression condition = cloneNodes(_n.getCondition(), _arg); - Expression thenExpr = cloneNodes(_n.getThenExpr(), _arg); - Expression elseExpr = cloneNodes(_n.getElseExpr(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression condition = cloneNode(_n.getCondition(), _arg); + Expression thenExpr = cloneNode(_n.getThenExpr(), _arg); + Expression elseExpr = cloneNode(_n.getElseExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ConditionalExpr r = new ConditionalExpr( _n.getRange(), @@ -624,8 +554,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(EnclosedExpr _n, Object _arg) { - Expression inner = cloneNodes(_n.getInner(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<Expression> inner = cloneNode(_n.getInner(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); EnclosedExpr r = new EnclosedExpr( _n.getRange(), @@ -637,15 +567,16 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(FieldAccessExpr _n, Object _arg) { - Expression scope_ = cloneNodes(_n.getScope(), _arg); - List<Type<?>> typeArguments_ = visit(_n.getTypeArguments(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression scope_ = cloneNode(_n.getScope(), _arg); + Optional<NodeList<Type<?>>> typeArguments_ = cloneList(_n.getTypeArguments(), _arg); + NameExpr fieldExpr_ = cloneNode(_n.getFieldExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); FieldAccessExpr r = new FieldAccessExpr( _n.getRange(), scope_, typeArguments_, - _n.getField() + fieldExpr_ ); r.setComment(comment); return r; @@ -653,9 +584,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(InstanceOfExpr _n, Object _arg) { - Expression expr = cloneNodes(_n.getExpr(), _arg); - Type<?> type_ = cloneNodes(_n.getType(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression expr = cloneNode(_n.getExpr(), _arg); + ReferenceType<?> type_ = cloneNode(_n.getType(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); InstanceOfExpr r = new InstanceOfExpr( _n.getRange(), @@ -667,7 +598,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(StringLiteralExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); StringLiteralExpr r = new StringLiteralExpr( _n.getRange(), _n.getValue() @@ -678,7 +609,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(IntegerLiteralExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); IntegerLiteralExpr r = new IntegerLiteralExpr( _n.getRange(), @@ -690,7 +621,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(LongLiteralExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); LongLiteralExpr r = new LongLiteralExpr( _n.getRange(), @@ -702,7 +633,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(IntegerLiteralMinValueExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); IntegerLiteralMinValueExpr r = new IntegerLiteralMinValueExpr(_n.getRange()); r.setComment(comment); @@ -711,7 +642,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(LongLiteralMinValueExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); LongLiteralMinValueExpr r = new LongLiteralMinValueExpr(_n.getRange()); r.setComment(comment); @@ -720,7 +651,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(CharLiteralExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); CharLiteralExpr r = new CharLiteralExpr( _n.getRange(), @@ -732,7 +663,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(DoubleLiteralExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); DoubleLiteralExpr r = new DoubleLiteralExpr( _n.getRange(), @@ -744,7 +675,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(BooleanLiteralExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); BooleanLiteralExpr r = new BooleanLiteralExpr( _n.getRange(), @@ -756,7 +687,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(NullLiteralExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); NullLiteralExpr r = new NullLiteralExpr(_n.getRange()); r.setComment(comment); @@ -765,17 +696,18 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(MethodCallExpr _n, Object _arg) { - Expression scope_ = cloneNodes(_n.getScope(), _arg); - List<Type<?>> typeArguments_ = visit(_n.getTypeArguments(), _arg); - List<Expression> args_ = visit(_n.getArgs(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<Expression> scope_ = cloneNode(_n.getScope(), _arg); + Optional<NodeList<Type<?>>> typeArguments_ = cloneList(_n.getTypeArguments(), _arg); + NodeList<Expression> args = cloneList(_n.getArgs(), _arg); + NameExpr nameExpr = cloneNode(_n.getNameExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); MethodCallExpr r = new MethodCallExpr( _n.getRange(), scope_, typeArguments_, - _n.getName(), - args_ + nameExpr, + args ); r.setComment(comment); return r; @@ -783,7 +715,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(NameExpr _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); NameExpr r = new NameExpr( _n.getRange(), @@ -795,16 +727,16 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ObjectCreationExpr _n, Object _arg) { - Expression scope = cloneNodes(_n.getScope(), _arg); - ClassOrInterfaceType type_ = cloneNodes(_n.getType(), _arg); - List<Type<?>> typeArgs = visit(_n.getTypeArguments(), _arg); - List<Expression> args = visit(_n.getArgs(), _arg); - List<BodyDeclaration<?>> anonymousBody = visit(_n.getAnonymousClassBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<Expression> scope = cloneNode(_n.getScope(), _arg); + ClassOrInterfaceType type_ = cloneNode(_n.getType(), _arg); + Optional<NodeList<Type<?>>> typeArguments = cloneList(_n.getTypeArguments(), _arg); + NodeList<Expression> args = cloneList(_n.getArgs(), _arg); + Optional<NodeList<BodyDeclaration<?>>> anonymousBody = cloneList(_n.getAnonymousClassBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ObjectCreationExpr r = new ObjectCreationExpr( _n.getRange(), - scope, type_, typeArgs, args, anonymousBody + scope, type_, typeArguments, args, anonymousBody ); r.setComment(comment); return r; @@ -812,8 +744,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(QualifiedNameExpr _n, Object _arg) { - NameExpr scope = cloneNodes(_n.getQualifier(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NameExpr scope = cloneNode(_n.getQualifier(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); QualifiedNameExpr r = new QualifiedNameExpr( _n.getRange(), @@ -825,8 +757,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ThisExpr _n, Object _arg) { - Expression classExpr = cloneNodes(_n.getClassExpr(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<Expression> classExpr = cloneNode(_n.getClassExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ThisExpr r = new ThisExpr( _n.getRange(), @@ -838,8 +770,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(SuperExpr _n, Object _arg) { - Expression classExpr = cloneNodes(_n.getClassExpr(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<Expression> classExpr = cloneNode(_n.getClassExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); SuperExpr r = new SuperExpr( _n.getRange(), @@ -851,8 +783,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(UnaryExpr _n, Object _arg) { - Expression expr = cloneNodes(_n.getExpr(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression expr = cloneNode(_n.getExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); UnaryExpr r = new UnaryExpr( _n.getRange(), @@ -864,18 +796,18 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(VariableDeclarationExpr _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); - Type<?> type_ = cloneNodes(_n.getElementType(), _arg); - List<VariableDeclarator> vars = visit(_n.getVariables(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); - List<ArrayBracketPair> arrayBracketPairsAfterType_ = visit(_n.getArrayBracketPairsAfterElementType(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); + Type<?> type_ = cloneNode(_n.getElementType(), _arg); + NodeList<VariableDeclarator> variables_ = cloneList(_n.getVariables(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); + NodeList<ArrayBracketPair> arrayBracketPairsAfterType_ = cloneList(_n.getArrayBracketPairsAfterElementType(), _arg); VariableDeclarationExpr r = new VariableDeclarationExpr( _n.getRange(), _n.getModifiers(), annotations, type_, - vars, + variables_, arrayBracketPairsAfterType_ ); r.setComment(comment); @@ -884,8 +816,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(MarkerAnnotationExpr _n, Object _arg) { - NameExpr name = cloneNodes(_n.getName(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NameExpr name = cloneNode(_n.getName(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); MarkerAnnotationExpr r = new MarkerAnnotationExpr( _n.getRange(), @@ -897,9 +829,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(SingleMemberAnnotationExpr _n, Object _arg) { - NameExpr name = cloneNodes(_n.getName(), _arg); - Expression memberValue = cloneNodes(_n.getMemberValue(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NameExpr name = cloneNode(_n.getName(), _arg); + Expression memberValue = cloneNode(_n.getMemberValue(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); SingleMemberAnnotationExpr r = new SingleMemberAnnotationExpr( _n.getRange(), @@ -911,9 +843,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(NormalAnnotationExpr _n, Object _arg) { - NameExpr name = cloneNodes(_n.getName(), _arg); - List<MemberValuePair> pairs = visit(_n.getPairs(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NameExpr name = cloneNode(_n.getName(), _arg); + NodeList<MemberValuePair> pairs = cloneList(_n.getPairs(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); NormalAnnotationExpr r = new NormalAnnotationExpr( _n.getRange(), @@ -925,8 +857,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(MemberValuePair _n, Object _arg) { - Expression value = cloneNodes(_n.getValue(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression value = cloneNode(_n.getValue(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); MemberValuePair r = new MemberValuePair( _n.getRange(), @@ -938,17 +870,17 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ExplicitConstructorInvocationStmt _n, Object _arg) { - List<Type<?>> typeArguments_ = visit(_n.getTypeArguments(), _arg); - Expression expr_ = cloneNodes(_n.getExpr(), _arg); - List<Expression> args_ = visit(_n.getArgs(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<NodeList<Type<?>>> typeArguments_ = cloneList(_n.getTypeArguments(), _arg); + Optional<Expression> expr_ = cloneNode(_n.getExpr(), _arg); + NodeList<Expression> args = cloneList(_n.getArgs(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ExplicitConstructorInvocationStmt r = new ExplicitConstructorInvocationStmt( _n.getRange(), typeArguments_, _n.isThis(), expr_, - args_ + args ); r.setComment(comment); return r; @@ -956,8 +888,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(TypeDeclarationStmt _n, Object _arg) { - TypeDeclaration<?> typeDecl = cloneNodes(_n.getTypeDeclaration(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + TypeDeclaration<?> typeDecl = cloneNode(_n.getTypeDeclaration(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); TypeDeclarationStmt r = new TypeDeclarationStmt( _n.getRange(), @@ -969,9 +901,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(AssertStmt _n, Object _arg) { - Expression check = cloneNodes(_n.getCheck(), _arg); - Expression message = cloneNodes(_n.getMessage(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression check = cloneNode(_n.getCheck(), _arg); + Optional<Expression> message = cloneNode(_n.getMessage(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); AssertStmt r = new AssertStmt( _n.getRange(), @@ -983,8 +915,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(BlockStmt _n, Object _arg) { - List<Statement> stmts = visit(_n.getStmts(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<Statement> stmts = cloneList(_n.getStmts(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); BlockStmt r = new BlockStmt( _n.getRange(), @@ -996,8 +928,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(LabeledStmt _n, Object _arg) { - Statement stmt = cloneNodes(_n.getStmt(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Statement stmt = cloneNode(_n.getStmt(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); LabeledStmt r = new LabeledStmt( _n.getRange(), @@ -1009,7 +941,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(EmptyStmt _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); EmptyStmt r = new EmptyStmt(_n.getRange()); r.setComment(comment); @@ -1018,8 +950,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ExpressionStmt _n, Object _arg) { - Expression expr = cloneNodes(_n.getExpression(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression expr = cloneNode(_n.getExpression(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ExpressionStmt r = new ExpressionStmt( _n.getRange(), @@ -1031,9 +963,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(SwitchStmt _n, Object _arg) { - Expression selector = cloneNodes(_n.getSelector(), _arg); - List<SwitchEntryStmt> entries = visit(_n.getEntries(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression selector = cloneNode(_n.getSelector(), _arg); + NodeList<SwitchEntryStmt> entries = cloneList(_n.getEntries(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); SwitchStmt r = new SwitchStmt( _n.getRange(), @@ -1045,9 +977,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(SwitchEntryStmt _n, Object _arg) { - Expression label = cloneNodes(_n.getLabel(), _arg); - List<Statement> stmts = visit(_n.getStmts(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<Expression> label = cloneNode(_n.getLabel(), _arg); + NodeList<Statement> stmts = cloneList(_n.getStmts(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); SwitchEntryStmt r = new SwitchEntryStmt( _n.getRange(), @@ -1059,7 +991,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(BreakStmt _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); BreakStmt r = new BreakStmt( _n.getRange(), @@ -1071,8 +1003,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ReturnStmt _n, Object _arg) { - Expression expr = cloneNodes(_n.getExpr(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<Expression> expr = cloneNode(_n.getExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ReturnStmt r = new ReturnStmt( _n.getRange(), @@ -1084,10 +1016,10 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(IfStmt _n, Object _arg) { - Expression condition = cloneNodes(_n.getCondition(), _arg); - Statement thenStmt = cloneNodes(_n.getThenStmt(), _arg); - Statement elseStmt = cloneNodes(_n.getElseStmt(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression condition = cloneNode(_n.getCondition(), _arg); + Statement thenStmt = cloneNode(_n.getThenStmt(), _arg); + Optional<Statement> elseStmt = cloneNode(_n.getElseStmt(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); IfStmt r = new IfStmt( _n.getRange(), @@ -1099,9 +1031,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(WhileStmt _n, Object _arg) { - Expression condition = cloneNodes(_n.getCondition(), _arg); - Statement body = cloneNodes(_n.getBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression condition = cloneNode(_n.getCondition(), _arg); + Statement body = cloneNode(_n.getBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); WhileStmt r = new WhileStmt( _n.getRange(), @@ -1113,7 +1045,7 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ContinueStmt _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ContinueStmt r = new ContinueStmt( _n.getRange(), @@ -1125,9 +1057,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(DoStmt _n, Object _arg) { - Statement body = cloneNodes(_n.getBody(), _arg); - Expression condition = cloneNodes(_n.getCondition(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Statement body = cloneNode(_n.getBody(), _arg); + Expression condition = cloneNode(_n.getCondition(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); DoStmt r = new DoStmt( _n.getRange(), @@ -1139,10 +1071,10 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ForeachStmt _n, Object _arg) { - VariableDeclarationExpr var = cloneNodes(_n.getVariable(), _arg); - Expression iterable = cloneNodes(_n.getIterable(), _arg); - Statement body = cloneNodes(_n.getBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + VariableDeclarationExpr var = cloneNode(_n.getVariable(), _arg); + Expression iterable = cloneNode(_n.getIterable(), _arg); + Statement body = cloneNode(_n.getBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ForeachStmt r = new ForeachStmt( _n.getRange(), @@ -1154,11 +1086,11 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ForStmt _n, Object _arg) { - List<Expression> init = visit(_n.getInit(), _arg); - Expression compare = cloneNodes(_n.getCompare(), _arg); - List<Expression> update = visit(_n.getUpdate(), _arg); - Statement body = cloneNodes(_n.getBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<Expression> init = cloneList(_n.getInit(), _arg); + Optional<Expression> compare = cloneNode(_n.getCompare(), _arg); + NodeList<Expression> update = cloneList(_n.getUpdate(), _arg); + Statement body = cloneNode(_n.getBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ForStmt r = new ForStmt( _n.getRange(), @@ -1170,8 +1102,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(ThrowStmt _n, Object _arg) { - Expression expr = cloneNodes(_n.getExpr(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression expr = cloneNode(_n.getExpr(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); ThrowStmt r = new ThrowStmt( _n.getRange(), @@ -1183,9 +1115,9 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(SynchronizedStmt _n, Object _arg) { - Expression expr = cloneNodes(_n.getExpr(), _arg); - BlockStmt block = cloneNodes(_n.getBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Expression expr = cloneNode(_n.getExpr(), _arg); + BlockStmt block = cloneNode(_n.getBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); SynchronizedStmt r = new SynchronizedStmt( _n.getRange(), @@ -1197,11 +1129,11 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(TryStmt _n, Object _arg) { - List<VariableDeclarationExpr> resources = visit(_n.getResources(),_arg); - BlockStmt tryBlock = cloneNodes(_n.getTryBlock(), _arg); - List<CatchClause> catchs = visit(_n.getCatchs(), _arg); - BlockStmt finallyBlock = cloneNodes(_n.getFinallyBlock(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NodeList<VariableDeclarationExpr> resources = cloneList(_n.getResources(),_arg); + BlockStmt tryBlock = cloneNode(_n.getTryBlock(), _arg); + NodeList<CatchClause> catchs = cloneList(_n.getCatchs(), _arg); + Optional<BlockStmt> finallyBlock = cloneNode(_n.getFinallyBlock(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); TryStmt r = new TryStmt( _n.getRange(), @@ -1213,24 +1145,20 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(CatchClause _n, Object _arg) { - Parameter param = cloneNodes(_n.getParam(), _arg); - BlockStmt catchBlock = cloneNodes(_n.getBody(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + Parameter param = cloneNode(_n.getParam(), _arg); + BlockStmt catchBlock = cloneNode(_n.getBody(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); - CatchClause r = new CatchClause( - _n.getRange(), - param.getModifiers(), param.getAnnotations(), param.getElementType(), param.getId(), catchBlock - ); + CatchClause r = new CatchClause(_n.getRange(), param, catchBlock); r.setComment(comment); return r; } @Override public Node visit(LambdaExpr _n, Object _arg) { + NodeList<Parameter> lambdaParameters = cloneList(_n.getParameters(), _arg); - List<Parameter> lambdaParameters = visit(_n.getParameters(), _arg); - - Statement body = cloneNodes(_n.getBody(), _arg); + Statement body = cloneNode(_n.getBody(), _arg); return new LambdaExpr(_n.getRange(), lambdaParameters, body, _n.isParametersEnclosed()); @@ -1239,37 +1167,50 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(MethodReferenceExpr _n, Object arg) { - Expression scope = cloneNodes(_n.getScope(), arg); + Expression scope = cloneNode(_n.getScope(), arg); + Optional<NodeList<Type<?>>> typeArguments = cloneList(_n.getTypeArguments(), arg); return new MethodReferenceExpr(_n.getRange(), scope, - _n.getTypeArguments(), _n.getIdentifier()); + typeArguments, _n.getIdentifier()); } @Override public Node visit(TypeExpr n, Object arg) { - Type<?> t = cloneNodes(n.getType(), arg); + Type<?> t = cloneNode(n.getType(), arg); return new TypeExpr(n.getRange(), t); } @Override public Node visit(ArrayBracketPair _n, Object _arg) { - List<AnnotationExpr> annotations = visit(_n.getAnnotations(), _arg); + NodeList<AnnotationExpr> annotations = cloneList(_n.getAnnotations(), _arg); return new ArrayBracketPair(_n.getRange(), annotations); } @Override + public Node visit(NodeList n, Object arg) { + NodeList<Node> newNodes = new NodeList<>(n.getRange(), null); + for (Object node : n) { + Node resultNode = ((Node)node).accept(this, arg); + if(resultNode!=null){ + newNodes.add(resultNode); + } + } + return newNodes; + } + + @Override public Node visit(EmptyImportDeclaration _n, Object _arg) { - Comment comment = cloneNodes(_n.getComment(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); return new EmptyImportDeclaration(_n.getRange()).setComment(comment); } @Override public Node visit(SingleStaticImportDeclaration _n, Object _arg) { - ClassOrInterfaceType type_ = cloneNodes(_n.getType(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + ClassOrInterfaceType type_ = cloneNode(_n.getType(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); SingleStaticImportDeclaration r = new SingleStaticImportDeclaration( @@ -1283,8 +1224,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(SingleTypeImportDeclaration _n, Object _arg) { - ClassOrInterfaceType type_ = cloneNodes(_n.getType(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + ClassOrInterfaceType type_ = cloneNode(_n.getType(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); SingleTypeImportDeclaration r = new SingleTypeImportDeclaration( _n.getRange(), @@ -1296,8 +1237,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(StaticImportOnDemandDeclaration _n, Object _arg) { - ClassOrInterfaceType type_ = cloneNodes(_n.getType(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + ClassOrInterfaceType type_ = cloneNode(_n.getType(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); StaticImportOnDemandDeclaration r = new StaticImportOnDemandDeclaration( _n.getRange(), @@ -1309,8 +1250,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { @Override public Node visit(TypeImportOnDemandDeclaration _n, Object _arg) { - NameExpr name = cloneNodes(_n.getName(), _arg); - Comment comment = cloneNodes(_n.getComment(), _arg); + NameExpr name = cloneNode(_n.getName(), _arg); + Optional<? extends Comment> comment = cloneNode(_n.getComment(), _arg); TypeImportOnDemandDeclaration r = new TypeImportOnDemandDeclaration( _n.getRange(), @@ -1320,20 +1261,8 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { return r; } - public <T extends Node> List<T> visit(List<T> _nodes, Object _arg) { - if (_nodes == null) - return null; - List<T> r = new ArrayList<>(_nodes.size()); - for (T n : _nodes) { - T rN = cloneNodes(n, _arg); - if (rN != null) - r.add(rN); - } - return r; - } - @SuppressWarnings("unchecked") - protected <T extends Node> T cloneNodes(T _node, Object _arg) { + protected <T extends Node> T cloneNode(T _node, Object _arg) { if (_node == null) return null; Node r = _node.accept(this, _arg); @@ -1341,4 +1270,21 @@ public class CloneVisitor implements GenericVisitor<Node, Object> { return null; return (T) r; } + + protected <N extends Node> Optional<N> cloneNode(Optional<N> optionalNode, Object arg) { + return optionalNode.flatMap(n -> option(cloneNode(n, arg))); + } + + + private <N extends Node> NodeList<N> cloneList(NodeList<N> list, Object _arg) { + if (list == null) { + return null; + } + return (NodeList<N>) list.accept(this, _arg); + } + + private <N extends Node> Optional<NodeList<N>> cloneList(Optional<NodeList<N>> optionalList, Object _arg) { + return optionalList.flatMap(l -> option((NodeList<N>) l.accept(this, _arg))); + } + } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/DumpVisitor.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/DumpVisitor.java index 63b67efcb..052a0671e 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/DumpVisitor.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/DumpVisitor.java @@ -33,15 +33,11 @@ import com.github.javaparser.ast.nodeTypes.NodeWithTypeArguments; import com.github.javaparser.ast.stmt.*; import com.github.javaparser.ast.type.*; -import java.util.EnumSet; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; +import java.util.*; import java.util.stream.Collectors; import static com.github.javaparser.utils.PositionUtils.sortByBeginPosition; import static com.github.javaparser.utils.Utils.EOL; -import static com.github.javaparser.utils.Utils.isNullOrEmpty; /** * Dumps the AST to formatted Java source code. @@ -131,7 +127,7 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print(modifiers.stream().map(Modifier::getLib).collect(Collectors.joining(" ")) + " "); } - private void printMembers(final List<BodyDeclaration<?>> members, final Object arg) { + private void printMembers(final NodeList<BodyDeclaration<?>> members, final Object arg) { for (final BodyDeclaration<?> member : members) { printer.printLn(); member.accept(this, arg); @@ -139,30 +135,32 @@ public class DumpVisitor implements VoidVisitor<Object> { } } - private void printMemberAnnotations(final List<AnnotationExpr> annotations, final Object arg) { - if (!isNullOrEmpty(annotations)) { - for (final AnnotationExpr a : annotations) { - a.accept(this, arg); - printer.printLn(); - } + private void printMemberAnnotations(final NodeList<AnnotationExpr> annotations, final Object arg) { + if(annotations.isEmpty()){ + return; + } + for (final AnnotationExpr a : annotations) { + a.accept(this, arg); + printer.printLn(); } } - private void printAnnotations(final List<AnnotationExpr> annotations, boolean prefixWithASpace, final Object arg) { - if (!isNullOrEmpty(annotations)) { - if(prefixWithASpace){ - printer.print(" "); - } - for (AnnotationExpr annotation : annotations) { - annotation.accept(this, arg); - printer.print(" "); - } + private void printAnnotations(final NodeList<AnnotationExpr> annotations, boolean prefixWithASpace, final Object arg) { + if(annotations.isEmpty()){ + return; + } + if (prefixWithASpace) { + printer.print(" "); + } + for (AnnotationExpr annotation : annotations) { + annotation.accept(this, arg); + printer.print(" "); } } private void printTypeArgs(final NodeWithTypeArguments<?> nodeWithTypeArguments, final Object arg) { - List<Type<?>> typeArguments = nodeWithTypeArguments.getTypeArguments(); - if (!isNullOrEmpty(typeArguments)) { + Optional<NodeList<Type<?>>> optionalTypeArguments = nodeWithTypeArguments.getTypeArguments(); + optionalTypeArguments.ifPresent( typeArguments -> { printer.print("<"); for (final Iterator<Type<?>> i = typeArguments.iterator(); i.hasNext(); ) { final Type<?> t = i.next(); @@ -172,65 +170,55 @@ public class DumpVisitor implements VoidVisitor<Object> { } } printer.print(">"); - } - } - - private void printTypeParameters(final List<TypeParameter> args, final Object arg) { - if (!isNullOrEmpty(args)) { - printer.print("<"); - for (final Iterator<TypeParameter> i = args.iterator(); i.hasNext(); ) { - final TypeParameter t = i.next(); - t.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - printer.print(">"); - } + }); + } + + private void printTypeParameters(final NodeList<TypeParameter> args, final Object arg) { + args.ifNotEmpty(tp -> { + printer.print("<"); + for (final Iterator<TypeParameter> i = tp.iterator(); i.hasNext(); ) { + final TypeParameter t = i.next(); + t.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } + printer.print(">"); + }); } - private void printArguments(final List<Expression> args, final Object arg) { + private void printArguments(final NodeList<Expression> args, final Object arg) { printer.print("("); - if (!isNullOrEmpty(args)) { - for (final Iterator<Expression> i = args.iterator(); i.hasNext(); ) { - final Expression e = i.next(); - e.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } + for (final Iterator<Expression> i = args.iterator(); i.hasNext(); ) { + final Expression e = i.next(); + e.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } printer.print(")"); } - private void printJavaComment(final Comment javacomment, final Object arg) { - if (javacomment != null) { - javacomment.accept(this, arg); - } + private void printJavaComment(final Optional<? extends Comment> javacomment, final Object arg) { + javacomment.ifPresent(c -> c.accept(this, arg)); } @Override public void visit(final CompilationUnit n, final Object arg) { printJavaComment(n.getComment(), arg); - if (n.getPackage() != null) { - n.getPackage().accept(this, arg); - } + n.getPackage().ifPresent(p -> p.accept(this, arg)); - if (!isNullOrEmpty(n.getImports())) { - for (final ImportDeclaration i : n.getImports()) { - i.accept(this, arg); - } + n.getImports().accept(this, arg); + if(!n.getImports().isEmpty()){ printer.printLn(); } - if (!isNullOrEmpty(n.getTypes())) { - for (final Iterator<TypeDeclaration<?>> i = n.getTypes().iterator(); i.hasNext(); ) { - i.next().accept(this, arg); + for (final Iterator<TypeDeclaration<?>> i = n.getTypes().iterator(); i.hasNext(); ) { + i.next().accept(this, arg); + printer.printLn(); + if (i.hasNext()) { printer.printLn(); - if (i.hasNext()) { - printer.printLn(); - } } } @@ -283,33 +271,31 @@ public class DumpVisitor implements VoidVisitor<Object> { printTypeParameters(n.getTypeParameters(), arg); - if (!isNullOrEmpty(n.getExtends())) { - printer.print(" extends "); - for (final Iterator<ClassOrInterfaceType> i = n.getExtends().iterator(); i.hasNext(); ) { - final ClassOrInterfaceType c = i.next(); - c.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } - - if (!isNullOrEmpty(n.getImplements())) { - printer.print(" implements "); - for (final Iterator<ClassOrInterfaceType> i = n.getImplements().iterator(); i.hasNext(); ) { - final ClassOrInterfaceType c = i.next(); - c.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } - + if(!n.getExtends().isEmpty()) { + printer.print(" extends "); + for (final Iterator<ClassOrInterfaceType> i = n.getExtends().iterator(); i.hasNext(); ) { + final ClassOrInterfaceType c = i.next(); + c.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } + } + + if(!n.getImplements().isEmpty()) { + printer.print(" implements "); + for (final Iterator<ClassOrInterfaceType> i = n.getImplements().iterator(); i.hasNext(); ) { + final ClassOrInterfaceType c = i.next(); + c.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } + } + printer.printLn(" {"); printer.indent(); - if (!isNullOrEmpty(n.getMembers())) { - printMembers(n.getMembers(), arg); - } + printMembers(n.getMembers(), arg); printOrphanCommentsEnding(n); @@ -336,10 +322,10 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final ClassOrInterfaceType n, final Object arg) { printJavaComment(n.getComment(), arg); - if (n.getScope() != null) { - n.getScope().accept(this, arg); + n.getScope().ifPresent(s -> { + s.accept(this, arg); printer.print("."); - } + }); for (AnnotationExpr ae : n.getAnnotations()) { ae.accept(this, arg); printer.print(" "); @@ -362,16 +348,16 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print(" "); } printer.print(n.getName()); - if (!isNullOrEmpty(n.getTypeBound())) { + n.getTypeBound().ifNotEmpty(tb -> { printer.print(" extends "); - for (final Iterator<ClassOrInterfaceType> i = n.getTypeBound().iterator(); i.hasNext(); ) { + for (final Iterator<ClassOrInterfaceType> i = tb.iterator(); i.hasNext(); ) { final ClassOrInterfaceType c = i.next(); c.accept(this, arg); if (i.hasNext()) { printer.print(" & "); } } - } + }); } @Override @@ -427,9 +413,7 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final ArrayCreationLevel n, final Object arg) { printAnnotations(n.getAnnotations(), true, arg); printer.print("["); - if (n.getDimension() != null) { - n.getDimension().accept(this, arg); - } + n.getDimension().ifPresent(d->d.accept(this, arg)); printer.print("]"); } @@ -468,14 +452,14 @@ public class DumpVisitor implements VoidVisitor<Object> { printJavaComment(n.getComment(), arg); printAnnotations(n.getAnnotations(), false, arg); printer.print("?"); - if (n.getExtends() != null) { + n.getExtends().ifPresent(e -> { printer.print(" extends "); - n.getExtends().accept(this, arg); - } - if (n.getSuper() != null) { + e.accept(this, arg); + }); + n.getSuper().ifPresent( s -> { printer.print(" super "); - n.getSuper().accept(this, arg); - } + s.accept(this, arg); + }); } @Override @@ -511,10 +495,10 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final VariableDeclarator n, final Object arg) { printJavaComment(n.getComment(), arg); n.getId().accept(this, arg); - if (n.getInit() != null) { + n.getInit().ifPresent( i -> { printer.print(" = "); - n.getInit().accept(this, arg); - } + i.accept(this, arg); + }); } @Override @@ -530,9 +514,9 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final ArrayInitializerExpr n, final Object arg) { printJavaComment(n.getComment(), arg); printer.print("{"); - if (!isNullOrEmpty(n.getValues())) { + n.getValues().ifNotEmpty(v -> { printer.print(" "); - for (final Iterator<Expression> i = n.getValues().iterator(); i.hasNext(); ) { + for (final Iterator<Expression> i = v.iterator(); i.hasNext(); ) { final Expression expr = i.next(); expr.accept(this, arg); if (i.hasNext()) { @@ -540,7 +524,7 @@ public class DumpVisitor implements VoidVisitor<Object> { } } printer.print(" "); - } + }); printer.print("}"); } @@ -564,14 +548,14 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final ArrayCreationExpr n, final Object arg) { printJavaComment(n.getComment(), arg); printer.print("new "); - n.getType().accept(this, arg); + n.getElementType().accept(this, arg); for (ArrayCreationLevel level : n.getLevels()) { level.accept(this, arg); } - if (n.getInitializer() != null) { + n.getInitializer().ifPresent(i -> { printer.print(" "); - n.getInitializer().accept(this, arg); - } + i.accept(this, arg); + }); } @Override @@ -719,9 +703,7 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final EnclosedExpr n, final Object arg) { printJavaComment(n.getComment(), arg); printer.print("("); - if (n.getInner() != null) { - n.getInner().accept(this, arg); - } + n.getInner().ifPresent(i -> i.accept(this, arg)); printer.print(")"); } @@ -802,30 +784,30 @@ public class DumpVisitor implements VoidVisitor<Object> { @Override public void visit(final ThisExpr n, final Object arg) { printJavaComment(n.getComment(), arg); - if (n.getClassExpr() != null) { - n.getClassExpr().accept(this, arg); + n.getClassExpr().ifPresent(ce -> { + ce.accept(this, arg); printer.print("."); - } + }); printer.print("this"); } @Override public void visit(final SuperExpr n, final Object arg) { printJavaComment(n.getComment(), arg); - if (n.getClassExpr() != null) { - n.getClassExpr().accept(this, arg); + n.getClassExpr().ifPresent(ce ->{ + ce.accept(this, arg); printer.print("."); - } + }); printer.print("super"); } @Override public void visit(final MethodCallExpr n, final Object arg) { printJavaComment(n.getComment(), arg); - if (n.getScope() != null) { - n.getScope().accept(this, arg); + n.getScope().ifPresent(s -> { + s.accept(this, arg); printer.print("."); - } + }); printTypeArgs(n, arg); printer.print(n.getName()); printArguments(n.getArgs(), arg); @@ -834,29 +816,27 @@ public class DumpVisitor implements VoidVisitor<Object> { @Override public void visit(final ObjectCreationExpr n, final Object arg) { printJavaComment(n.getComment(), arg); - if (n.getScope() != null) { - n.getScope().accept(this, arg); + n.getScope().ifPresent(s -> { + s.accept(this, arg); printer.print("."); - } + }); printer.print("new "); printTypeArgs(n, arg); - if (!isNullOrEmpty(n.getTypeArguments())) { - printer.print(" "); - } + n.getTypeArguments().ifPresent(t -> printer.print(" ")); n.getType().accept(this, arg); printArguments(n.getArgs(), arg); - if (n.getAnonymousClassBody() != null) { + n.getAnonymousClassBody().ifPresent(acb -> { printer.printLn(" {"); printer.indent(); - printMembers(n.getAnonymousClassBody(), arg); + printMembers(acb, arg); printer.unindent(); printer.print("}"); - } + }); } @Override @@ -887,10 +867,10 @@ public class DumpVisitor implements VoidVisitor<Object> { n.getExpr().accept(this, arg); switch (n.getOperator()) { - case posIncrement: + case postIncrement: printer.print("++"); break; - case posDecrement: + case postDecrement: printer.print("--"); break; default: @@ -904,7 +884,7 @@ public class DumpVisitor implements VoidVisitor<Object> { printModifiers(n.getModifiers()); printTypeParameters(n.getTypeParameters(), arg); - if (!n.getTypeParameters().isEmpty()) { + if (n.isGeneric()) { printer.print(" "); } printer.print(n.getName()); @@ -921,16 +901,16 @@ public class DumpVisitor implements VoidVisitor<Object> { } printer.print(")"); - if (!isNullOrEmpty(n.getThrows())) { + n.getThrows().ifNotEmpty(t -> { printer.print(" throws "); - for (final Iterator<ReferenceType> i = n.getThrows().iterator(); i.hasNext(); ) { - final ReferenceType name = i.next(); + for (final Iterator<ReferenceType<?>> i = t.iterator(); i.hasNext(); ) { + final ReferenceType<?> name = i.next(); name.accept(this, arg); if (i.hasNext()) { printer.print(", "); } } - } + }); printer.print(" "); n.getBody().accept(this, arg); } @@ -946,9 +926,7 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print("default "); } printTypeParameters(n.getTypeParameters(), arg); - if (!isNullOrEmpty(n.getTypeParameters())) { - printer.print(" "); - } + n.getTypeParameters().ifNotEmpty( tp -> printer.print(" ")); n.getElementType().accept(this, arg); for(ArrayBracketPair pair: n.getArrayBracketPairsAfterElementType()){ @@ -958,47 +936,43 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print(n.getName()); printer.print("("); - if (!isNullOrEmpty(n.getParameters())) { - for (final Iterator<Parameter> i = n.getParameters().iterator(); i.hasNext(); ) { - final Parameter p = i.next(); - p.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } + for (final Iterator<Parameter> i = n.getParameters().iterator(); i.hasNext(); ) { + final Parameter p = i.next(); + p.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } printer.print(")"); for(ArrayBracketPair pair: n.getArrayBracketPairsAfterParameterList()){ pair.accept(this, arg); } - if (!isNullOrEmpty(n.getThrows())) { + n.getThrows().ifNotEmpty(t -> { printer.print(" throws "); - for (final Iterator<ReferenceType> i = n.getThrows().iterator(); i.hasNext(); ) { + for (final Iterator<ReferenceType<?>> i = t.iterator(); i.hasNext(); ) { final ReferenceType name = i.next(); name.accept(this, arg); if (i.hasNext()) { printer.print(", "); } } - } - if (n.getBody() == null) { - printer.print(";"); - } else { - printer.print(" "); - n.getBody().accept(this, arg); - } - } + }); + if (n.getBody().isPresent()) { + printer.print(" "); + n.getBody().get().accept(this, arg); + } else { + printer.print(";"); + } + } @Override public void visit(final Parameter n, final Object arg) { printJavaComment(n.getComment(), arg); printAnnotations(n.getAnnotations(), false, arg); printModifiers(n.getModifiers()); - if (n.getElementType() != null) { - n.getElementType().accept(this, arg); - } + n.getElementType().accept(this, arg); for(ArrayBracketPair pair: n.getArrayBracketPairsAfterElementType()){ pair.accept(this, arg); } @@ -1016,10 +990,10 @@ public class DumpVisitor implements VoidVisitor<Object> { printTypeArgs(n, arg); printer.print("this"); } else { - if (n.getExpr() != null) { - n.getExpr().accept(this, arg); + n.getExpr().ifPresent(e -> { + e.accept(this, arg); printer.print("."); - } + }); printTypeArgs(n, arg); printer.print("super"); } @@ -1059,10 +1033,10 @@ public class DumpVisitor implements VoidVisitor<Object> { printJavaComment(n.getComment(), arg); printer.print("assert "); n.getCheck().accept(this, arg); - if (n.getMessage() != null) { + n.getMessage().ifPresent(m -> { printer.print(" : "); - n.getMessage().accept(this, arg); - } + m.accept(this, arg); + }); printer.print(";"); } @@ -1071,14 +1045,12 @@ public class DumpVisitor implements VoidVisitor<Object> { printOrphanCommentsBeforeThisChildNode(n); printJavaComment(n.getComment(), arg); printer.printLn("{"); - if (n.getStmts() != null) { - printer.indent(); - for (final Statement s : n.getStmts()) { - s.accept(this, arg); - printer.printLn(); - } - printer.unindent(); - } + printer.indent(); + for (final Statement s : n.getStmts()) { + s.accept(this, arg); + printer.printLn(); + } + printer.unindent(); printOrphanCommentsEnding(n); printer.print("}"); @@ -1112,13 +1084,11 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print("switch("); n.getSelector().accept(this, arg); printer.printLn(") {"); - if (n.getEntries() != null) { - printer.indent(); - for (final SwitchEntryStmt e : n.getEntries()) { - e.accept(this, arg); - } - printer.unindent(); - } + printer.indent(); + for (final SwitchEntryStmt e : n.getEntries()) { + e.accept(this, arg); + } + printer.unindent(); printer.print("}"); } @@ -1126,21 +1096,19 @@ public class DumpVisitor implements VoidVisitor<Object> { @Override public void visit(final SwitchEntryStmt n, final Object arg) { printJavaComment(n.getComment(), arg); - if (n.getLabel() != null) { + if (n.getLabel().isPresent()) { printer.print("case "); - n.getLabel().accept(this, arg); + n.getLabel().get().accept(this, arg); printer.print(":"); } else { printer.print("default:"); } printer.printLn(); printer.indent(); - if (n.getStmts() != null) { - for (final Statement s : n.getStmts()) { - s.accept(this, arg); - printer.printLn(); - } - } + for (final Statement s : n.getStmts()) { + s.accept(this, arg); + printer.printLn(); + } printer.unindent(); } @@ -1148,10 +1116,10 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final BreakStmt n, final Object arg) { printJavaComment(n.getComment(), arg); printer.print("break"); - if (n.getId() != null) { + n.getId().ifPresent(id -> { printer.print(" "); - printer.print(n.getId()); - } + printer.print(id); + }); printer.print(";"); } @@ -1159,10 +1127,10 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final ReturnStmt n, final Object arg) { printJavaComment(n.getComment(), arg); printer.print("return"); - if (n.getExpr() != null) { + n.getExpr().ifPresent( e-> { printer.print(" "); - n.getExpr().accept(this, arg); - } + e.accept(this, arg); + }); printer.print(";"); } @@ -1188,16 +1156,14 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.printLn(" {"); printer.indent(); - if (n.getEntries() != null) { - printer.printLn(); - for (final Iterator<EnumConstantDeclaration> i = n.getEntries().iterator(); i.hasNext(); ) { - final EnumConstantDeclaration e = i.next(); - e.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } + printer.printLn(); + for (final Iterator<EnumConstantDeclaration> i = n.getEntries().iterator(); i.hasNext(); ) { + final EnumConstantDeclaration e = i.next(); + e.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } if (!n.getMembers().isEmpty()) { printer.printLn(";"); printMembers(n.getMembers(), arg); @@ -1259,23 +1225,23 @@ public class DumpVisitor implements VoidVisitor<Object> { n.getThenStmt().accept(this, arg); if (!thenBlock) printer.unindent(); - if (n.getElseStmt() != null) { + n.getElseStmt().ifPresent(es -> { if (thenBlock) printer.print(" "); else printer.printLn(); - final boolean elseIf = n.getElseStmt() instanceof IfStmt; - final boolean elseBlock = n.getElseStmt() instanceof BlockStmt; + final boolean elseIf = es instanceof IfStmt; + final boolean elseBlock = es instanceof BlockStmt; if (elseIf || elseBlock) // put chained if and start of block statement on a same level printer.print("else "); else { printer.printLn("else"); printer.indent(); } - n.getElseStmt().accept(this, arg); + es.accept(this, arg); if (!(elseIf || elseBlock)) printer.unindent(); - } + }); } @Override @@ -1291,10 +1257,10 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final ContinueStmt n, final Object arg) { printJavaComment(n.getComment(), arg); printer.print("continue"); - if (n.getId() != null) { + n.getId().ifPresent(id -> { printer.print(" "); - printer.print(n.getId()); - } + printer.print(id); + }); printer.print(";"); } @@ -1323,29 +1289,23 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(final ForStmt n, final Object arg) { printJavaComment(n.getComment(), arg); printer.print("for ("); - if (n.getInit() != null) { - for (final Iterator<Expression> i = n.getInit().iterator(); i.hasNext(); ) { - final Expression e = i.next(); - e.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } + for (final Iterator<Expression> i = n.getInit().iterator(); i.hasNext(); ) { + final Expression e = i.next(); + e.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } printer.print("; "); - if (n.getCompare() != null) { - n.getCompare().accept(this, arg); - } + n.getCompare().ifPresent(c -> c.accept(this, arg)); printer.print("; "); - if (n.getUpdate() != null) { - for (final Iterator<Expression> i = n.getUpdate().iterator(); i.hasNext(); ) { - final Expression e = i.next(); - e.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } + for (final Iterator<Expression> i = n.getUpdate().iterator(); i.hasNext(); ) { + final Expression e = i.next(); + e.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } printer.print(") "); n.getBody().accept(this, arg); } @@ -1392,15 +1352,13 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print(") "); } n.getTryBlock().accept(this, arg); - if (n.getCatchs() != null) { - for (final CatchClause c : n.getCatchs()) { - c.accept(this, arg); - } - } - if (n.getFinallyBlock() != null) { + for (final CatchClause c : n.getCatchs()) { + c.accept(this, arg); + } + n.getFinallyBlock().ifPresent(fb -> { printer.print(" finally "); - n.getFinallyBlock().accept(this, arg); - } + fb.accept(this, arg); + }); } @Override @@ -1423,9 +1381,7 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print(n.getName()); printer.printLn(" {"); printer.indent(); - if (n.getMembers() != null) { - printMembers(n.getMembers(), arg); - } + printMembers(n.getMembers(), arg); printer.unindent(); printer.print("}"); } @@ -1440,10 +1396,10 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print(" "); printer.print(n.getName()); printer.print("()"); - if (n.getDefaultValue() != null) { + n.getDefaultValue().ifPresent(dv -> { printer.print(" default "); - n.getDefaultValue().accept(this, arg); - } + dv.accept(this, arg); + }); printer.print(";"); } @@ -1470,15 +1426,13 @@ public class DumpVisitor implements VoidVisitor<Object> { printer.print("@"); n.getName().accept(this, arg); printer.print("("); - if (n.getPairs() != null) { - for (final Iterator<MemberValuePair> i = n.getPairs().iterator(); i.hasNext(); ) { - final MemberValuePair m = i.next(); - m.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } - } - } + for (final Iterator<MemberValuePair> i = n.getPairs().iterator(); i.hasNext(); ) { + final MemberValuePair m = i.next(); + m.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); + } + } printer.print(")"); } @@ -1516,19 +1470,17 @@ public class DumpVisitor implements VoidVisitor<Object> { public void visit(LambdaExpr n, Object arg) { printJavaComment(n.getComment(), arg); - final List<Parameter> parameters = n.getParameters(); + final NodeList<Parameter> parameters = n.getParameters(); final boolean printPar = n.isParametersEnclosed(); if (printPar) { printer.print("("); } - if (parameters != null) { - for (Iterator<Parameter> i = parameters.iterator(); i.hasNext(); ) { - Parameter p = i.next(); - p.accept(this, arg); - if (i.hasNext()) { - printer.print(", "); - } + for (Iterator<Parameter> i = parameters.iterator(); i.hasNext(); ) { + Parameter p = i.next(); + p.accept(this, arg); + if (i.hasNext()) { + printer.print(", "); } } if (printPar) { @@ -1549,26 +1501,16 @@ public class DumpVisitor implements VoidVisitor<Object> { @Override public void visit(MethodReferenceExpr n, Object arg) { printJavaComment(n.getComment(), arg); - Expression scope = n.getScope(); - String identifier = n.getIdentifier(); - if (scope != null) { - n.getScope().accept(this, arg); - } - + n.getScope().accept(this, arg); printer.print("::"); printTypeArgs(n, arg); - if (identifier != null) { - printer.print(identifier); - } - + printer.print(n.getIdentifier()); } @Override public void visit(TypeExpr n, Object arg) { printJavaComment(n.getComment(), arg); - if (n.getType() != null) { - n.getType().accept(this, arg); - } + n.getType().accept(this, arg); } @Override @@ -1578,6 +1520,13 @@ public class DumpVisitor implements VoidVisitor<Object> { } @Override + public void visit(NodeList n, Object arg) { + for(Object node: n){ + ((Node)node).accept(this, arg); + } + } + + @Override public void visit(EmptyImportDeclaration n, Object arg) { printer.printLn(";"); } @@ -1624,15 +1573,20 @@ public class DumpVisitor implements VoidVisitor<Object> { if (node instanceof Comment) return; Node parent = node.getParentNode(); + while (parent != null && parent instanceof NodeList) { + parent = parent.getParentNode(); + } if (parent == null) return; List<Node> everything = new LinkedList<>(); - everything.addAll(parent.getChildrenNodes()); + everything.addAll(parent.getBackwardsCompatibleChildrenNodes()); sortByBeginPosition(everything); int positionOfTheChild = -1; for (int i = 0; i < everything.size(); i++) { if (everything.get(i) == node) positionOfTheChild = i; } - if (positionOfTheChild == -1) throw new RuntimeException("My index not found!!! " + node); + if (positionOfTheChild == -1) { + throw new AssertionError("I am not a child of my parent."); + } int positionOfPreviousChild = -1; for (int i = positionOfTheChild - 1; i >= 0 && positionOfPreviousChild == -1; i--) { if (!(everything.get(i) instanceof Comment)) positionOfPreviousChild = i; diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/EqualsVisitor.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/EqualsVisitor.java index 1537593ce..fbe3113ff 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/EqualsVisitor.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/EqualsVisitor.java @@ -32,6 +32,7 @@ import com.github.javaparser.ast.stmt.*; import com.github.javaparser.ast.type.*; import java.util.List; +import java.util.Optional; /** * @author Julio Vilmar Gesser @@ -58,8 +59,8 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { } return nodesEquals(n1.getOrphanComments(), n2.getOrphanComments()); } - - private <T extends Node> boolean nodesEquals(final List<T> nodes1, final List<T> nodes2) { + + private boolean nodesEquals(final List<? extends Node> nodes1, final List<? extends Node> nodes2) { if (nodes1 == null) { return nodes2 == null; } else if (nodes2 == null) { @@ -76,23 +77,71 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { return true; } - private <T extends Node> boolean nodeEquals(final T n1, final T n2) { - if (n1 == n2) { - return true; - } - if (n1 == null || n2 == null) { + public <N extends Node, L extends NodeList<N>> boolean nodesEquals(Optional<L> n1, Optional<L> n2) { + if (!n1.isPresent() && !n2.isPresent()) { + return true; + } + if (!n1.isPresent() || !n2.isPresent()) { + return false; + } + L t1 = n1.get(); + L t2 = n2.get(); + return nodesEquals(t1, t2); + } + + public <N extends Node> boolean nodesEquals(NodeList<N> n1, NodeList<N> n2) { + if (n1 == n2) { + return true; + } + if (n1 == null || n2 == null) { + return false; + } + if (n1.size() != n2.size()) { return false; } - if (n1.getClass() != n2.getClass()) { - return false; + for (int i = 0; i < n1.size(); i++) { + if (!nodeEquals(n1.get(i), n2.get(i))) { + return false; + } } + return true; + } + + private boolean nodeEquals(final Node n1, final Node n2) { + if (n1 == n2) { + return true; + } + if (n1 == null || n2 == null) { + return false; + } + if (n1.getClass() != n2.getClass()) { + return false; + } if (!commonNodeEquality(n1, n2)){ return false; } - return n1.accept(this, n2); - } + return n1.accept(this, n2); + } - private boolean objEquals(final Object n1, final Object n2) { + private boolean nodeEquals(final Optional<? extends Node> n1, final Optional<? extends Node> n2) { + if (!n1.isPresent() && !n2.isPresent()) { + return true; + } + if (!n1.isPresent() || !n2.isPresent()) { + return false; + } + Node t1 = n1.get(); + Node t2 = n2.get(); + if (t1.getClass() != t2.getClass()) { + return false; + } + if (!commonNodeEquality(t1, t2)){ + return false; + } + return t1.accept(this, t2); + } + + private boolean objEquals(final Object n1, final Object n2) { if (n1 == n2) { return true; } @@ -596,8 +645,8 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { return false; } - List<ReferenceType> n1Elements = n1.getElements(); - List<ReferenceType> n2Elements = n2.getElements(); + NodeList<ReferenceType<?>> n1Elements = n1.getElements(); + NodeList<ReferenceType<?>> n2Elements = n2.getElements(); if (n1Elements !=null && n2Elements != null) { if(n1Elements.size() != n2Elements.size()){ @@ -605,7 +654,7 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { } else{ int i = 0; - for(ReferenceType aux: n1Elements){ + for(ReferenceType<?> aux: n1Elements){ if(aux.accept(this, n2Elements.get(i))) { return false; } @@ -625,8 +674,8 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { return false; } - List<ReferenceType> n1Elements = n1.getElements(); - List<ReferenceType> n2Elements = n2.getElements(); + NodeList<ReferenceType<?>> n1Elements = n1.getElements(); + NodeList<ReferenceType<?>> n2Elements = n2.getElements(); if (n1Elements !=null && n2Elements != null) { if(n1Elements.size() != n2Elements.size()){ @@ -634,7 +683,7 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { } else{ int i = 0; - for(ReferenceType aux: n1Elements){ + for(ReferenceType<?> aux: n1Elements){ if(aux.accept(this, n2Elements.get(i))) { return false; } @@ -693,7 +742,7 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { @Override public Boolean visit(final ArrayCreationExpr n1, final Node arg) { final ArrayCreationExpr n2 = (ArrayCreationExpr) arg; - if (!nodeEquals(n1.getType(), n2.getType())) { + if (!nodeEquals(n1.getElementType(), n2.getElementType())) { return false; } @@ -1435,7 +1484,7 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { return true; } - @Override + @Override public Boolean visit(EmptyImportDeclaration n1, Node arg) { return true; } @@ -1482,6 +1531,11 @@ public class EqualsVisitor implements GenericVisitor<Boolean, Node> { return false; } - return true; + return true; + } + + @Override + public Boolean visit(NodeList n, Node arg) { + return nodesEquals((NodeList<Node>) n, (NodeList<Node>) arg); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitor.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitor.java index 2c159f941..fd6a57347 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitor.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitor.java @@ -252,7 +252,9 @@ public interface GenericVisitor<R, A> { R visit(TypeExpr n, A arg); - R visit(ArrayBracketPair n, A arg); + R visit(ArrayBracketPair arrayBracketPair, A arg); + + R visit(NodeList n, A arg); R visit(EmptyImportDeclaration n, A arg); diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitorAdapter.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitorAdapter.java index 0948fe4ec..4b7ddfa3d 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitorAdapter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/GenericVisitorAdapter.java @@ -32,6 +32,8 @@ import com.github.javaparser.ast.imports.*; import com.github.javaparser.ast.stmt.*; import com.github.javaparser.ast.type.*; +import static com.github.javaparser.utils.Utils.option; + /** * @author Julio Vilmar Gesser */ @@ -82,9 +84,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return result; } } - if (n.getDefaultValue() != null) { + if (n.getDefaultValue().isPresent()) { { - R result = n.getDefaultValue().accept(this, arg); + R result = n.getDefaultValue().get().accept(this, arg); if (result != null) { return result; } @@ -115,7 +117,7 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A public R visit(final ArrayCreationExpr n, final A arg) { visitComment(n, arg); { - R result = n.getType().accept(this, arg); + R result = n.getElementType().accept(this, arg); if (result != null) { return result; } @@ -126,8 +128,8 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return result; } } - if (n.getInitializer() != null) { - R result = n.getInitializer().accept(this, arg); + if (n.getInitializer().isPresent()) { + R result = n.getInitializer().get().accept(this, arg); if (result != null) { return result; } @@ -160,9 +162,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return result; } } - if (n.getMessage() != null) { + if (n.getMessage().isPresent()) { { - R result = n.getMessage().accept(this, arg); + R result = n.getMessage().get().accept(this, arg); if (result != null) { return result; } @@ -357,16 +359,16 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return result; } } - if (n.getScope() != null) { + if (n.getScope().isPresent()) { { - R result = n.getScope().accept(this, arg); + R result = n.getScope().get().accept(this, arg); if (result != null) { return result; } } } - if (n.getTypeArguments() != null) { - for (Type<?> type : n.getTypeArguments()) { + if (n.getTypeArguments().isPresent()) { + for (Type<?> type : n.getTypeArguments().get()) { R result = type.accept(this, arg); if (result != null) { return result; @@ -379,9 +381,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final CompilationUnit n, final A arg) { visitComment(n, arg); - if (n.getPackage() != null) { + if (n.getPackage().isPresent()) { { - R result = n.getPackage().accept(this, arg); + R result = n.getPackage().get().accept(this, arg); if (result != null) { return result; } @@ -537,8 +539,8 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final EnclosedExpr n, final A arg) { visitComment(n, arg); - { - R result = n.getInner().accept(this, arg); + if(n.getInner().isPresent()) { + R result = n.getInner().get().accept(this, arg); if (result != null) { return result; } @@ -631,16 +633,16 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final ExplicitConstructorInvocationStmt n, final A arg) { visitComment(n, arg); - if (!n.isThis() && n.getExpr() != null) { + if (!n.isThis() && n.getExpr().isPresent()) { { - R result = n.getExpr().accept(this, arg); + R result = n.getExpr().get().accept(this, arg); if (result != null) { return result; } } } - if (n.getTypeArguments() != null) { - for (Type<?> type : n.getTypeArguments()) { + if (n.getTypeArguments().isPresent()) { + for (Type<?> type : n.getTypeArguments().get()) { R result = type.accept(this, arg); if (result != null) { return result; @@ -682,8 +684,8 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A } } { - if (n.getTypeArguments() != null) { - for (Type<?> type : n.getTypeArguments()) { + if (n.getTypeArguments().isPresent()) { + for (Type<?> type : n.getTypeArguments().get()) { R result = type.accept(this, arg); if (result != null) { return result; @@ -761,9 +763,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A } } } - if (n.getCompare() != null) { + if (n.getCompare().isPresent()) { { - R result = n.getCompare().accept(this, arg); + R result = n.getCompare().get().accept(this, arg); if (result != null) { return result; } @@ -803,9 +805,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return result; } } - if (n.getElseStmt() != null) { + if (n.getElseStmt().isPresent()) { { - R result = n.getElseStmt().accept(this, arg); + R result = n.getElseStmt().get().accept(this, arg); if (result != null) { return result; } @@ -912,16 +914,16 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final MethodCallExpr n, final A arg) { visitComment(n, arg); - if (n.getScope() != null) { + if (n.getScope().isPresent()) { { - R result = n.getScope().accept(this, arg); + R result = n.getScope().get().accept(this, arg); if (result != null) { return result; } } } - if (n.getTypeArguments() != null) { - for (Type<?> type : n.getTypeArguments()) { + if (n.getTypeArguments().isPresent()) { + for (Type<?> type : n.getTypeArguments().get()) { R result = type.accept(this, arg); if (result != null) { return result; @@ -990,9 +992,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A } } } - if (n.getBody() != null) { + if (n.getBody().isPresent()) { { - R result = n.getBody().accept(this, arg); + R result = n.getBody().get().accept(this, arg); if (result != null) { return result; } @@ -1038,16 +1040,16 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final ObjectCreationExpr n, final A arg) { visitComment(n, arg); - if (n.getScope() != null) { + if (n.getScope().isPresent()) { { - R result = n.getScope().accept(this, arg); + R result = n.getScope().get().accept(this, arg); if (result != null) { return result; } } } - if (n.getTypeArguments() != null) { - for (Type<?> type : n.getTypeArguments()) { + if (n.getTypeArguments().isPresent()) { + for (Type<?> type : n.getTypeArguments().get()) { R result = type.accept(this, arg); if (result != null) { return result; @@ -1070,8 +1072,8 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A } } } - if (n.getAnonymousClassBody() != null) { - for (final BodyDeclaration<?> member : n.getAnonymousClassBody()) { + if (n.getAnonymousClassBody().isPresent()) { + for (final BodyDeclaration<?> member : n.getAnonymousClassBody().get()) { { R result = member.accept(this, arg); if (result != null) { @@ -1185,8 +1187,8 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A } } { - if(n.getDimension()!=null) { - R result = n.getDimension().accept(this, arg); + if(n.getDimension().isPresent()) { + R result = n.getDimension().get().accept(this, arg); if (result != null) { return result; } @@ -1238,9 +1240,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final ReturnStmt n, final A arg) { visitComment(n, arg); - if (n.getExpr() != null) { + if (n.getExpr().isPresent()) { { - R result = n.getExpr().accept(this, arg); + R result = n.getExpr().get().accept(this, arg); if (result != null) { return result; } @@ -1276,9 +1278,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final SuperExpr n, final A arg) { visitComment(n, arg); - if (n.getClassExpr() != null) { + if (n.getClassExpr().isPresent()) { { - R result = n.getClassExpr().accept(this, arg); + R result = n.getClassExpr().get().accept(this, arg); if (result != null) { return result; } @@ -1290,9 +1292,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final SwitchEntryStmt n, final A arg) { visitComment(n, arg); - if (n.getLabel() != null) { + if (n.getLabel().isPresent()) { { - R result = n.getLabel().accept(this, arg); + R result = n.getLabel().get().accept(this, arg); if (result != null) { return result; } @@ -1357,9 +1359,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A @Override public R visit(final ThisExpr n, final A arg) { visitComment(n, arg); - if (n.getClassExpr() != null) { + if (n.getClassExpr().isPresent()) { { - R result = n.getClassExpr().accept(this, arg); + R result = n.getClassExpr().get().accept(this, arg); if (result != null) { return result; } @@ -1409,9 +1411,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A } } } - if (n.getFinallyBlock() != null) { + if (n.getFinallyBlock().isPresent()) { { - R result = n.getFinallyBlock().accept(this, arg); + R result = n.getFinallyBlock().get().accept(this, arg); if (result != null) { return result; } @@ -1501,9 +1503,9 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return result; } } - if (n.getInit() != null) { + if (n.getInit().isPresent()) { { - R result = n.getInit().accept(this, arg); + R result = n.getInit().get().accept(this, arg); if (result != null) { return result; } @@ -1557,17 +1559,17 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return result; } } - if (n.getExtends() != null) { + if (n.getExtends().isPresent()) { { - R result = n.getExtends().accept(this, arg); + R result = n.getExtends().get().accept(this, arg); if (result != null) { return result; } } } - if (n.getSuper() != null) { + if (n.getSuper().isPresent()) { { - R result = n.getSuper().accept(this, arg); + R result = n.getSuper().get().accept(this, arg); if (result != null) { return result; } @@ -1600,8 +1602,8 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A public R visit(MethodReferenceExpr n, A arg) { visitComment(n, arg); { - if (n.getTypeArguments() != null) { - for (Type<?> type : n.getTypeArguments()) { + if (n.getTypeArguments().isPresent()) { + for (Type<?> type : n.getTypeArguments().get()) { R result = type.accept(this, arg); if (result != null) { return result; @@ -1707,12 +1709,21 @@ public abstract class GenericVisitorAdapter<R, A> implements GenericVisitor<R, A return null; } - private void visitComment(Node n, A arg) { - if(n.getComment()!=null){ - Comment result = (Comment) n.getComment().accept(this, arg); - if(result!=null){ - n.setComment(result); + @Override + public R visit(NodeList n, A arg) { + for (final Object v : n) { + R result = ((Node) v).accept(this, arg); + if (result != null) { + return result; } } + return null; + } + + private void visitComment(Node n, A arg) { + n.getComment().ifPresent(c -> { + Comment result = (Comment) c.accept(this, arg); + n.setComment(option(result)); + }); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/ModifierVisitorAdapter.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/ModifierVisitorAdapter.java index 878c28f55..40670dba9 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/ModifierVisitorAdapter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/ModifierVisitorAdapter.java @@ -21,92 +21,21 @@ package com.github.javaparser.ast.visitor; -import java.util.List; - import com.github.javaparser.ast.*; -import com.github.javaparser.ast.imports.*; -import com.github.javaparser.ast.type.TypeParameter; -import com.github.javaparser.ast.body.AnnotationDeclaration; -import com.github.javaparser.ast.body.AnnotationMemberDeclaration; -import com.github.javaparser.ast.body.BodyDeclaration; -import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; -import com.github.javaparser.ast.body.ConstructorDeclaration; -import com.github.javaparser.ast.body.EmptyMemberDeclaration; -import com.github.javaparser.ast.body.EmptyTypeDeclaration; -import com.github.javaparser.ast.body.EnumConstantDeclaration; -import com.github.javaparser.ast.body.EnumDeclaration; -import com.github.javaparser.ast.body.FieldDeclaration; -import com.github.javaparser.ast.body.InitializerDeclaration; -import com.github.javaparser.ast.body.MethodDeclaration; -import com.github.javaparser.ast.body.Parameter; -import com.github.javaparser.ast.body.TypeDeclaration; -import com.github.javaparser.ast.body.VariableDeclarator; -import com.github.javaparser.ast.body.VariableDeclaratorId; +import com.github.javaparser.ast.body.*; import com.github.javaparser.ast.comments.BlockComment; import com.github.javaparser.ast.comments.Comment; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.comments.LineComment; -import com.github.javaparser.ast.expr.AnnotationExpr; -import com.github.javaparser.ast.expr.ArrayAccessExpr; -import com.github.javaparser.ast.expr.ArrayCreationExpr; -import com.github.javaparser.ast.expr.ArrayInitializerExpr; -import com.github.javaparser.ast.expr.AssignExpr; -import com.github.javaparser.ast.expr.BinaryExpr; -import com.github.javaparser.ast.expr.BooleanLiteralExpr; -import com.github.javaparser.ast.expr.CastExpr; -import com.github.javaparser.ast.expr.CharLiteralExpr; -import com.github.javaparser.ast.expr.ClassExpr; -import com.github.javaparser.ast.expr.ConditionalExpr; -import com.github.javaparser.ast.expr.DoubleLiteralExpr; -import com.github.javaparser.ast.expr.EnclosedExpr; -import com.github.javaparser.ast.expr.Expression; -import com.github.javaparser.ast.expr.FieldAccessExpr; -import com.github.javaparser.ast.expr.InstanceOfExpr; -import com.github.javaparser.ast.expr.IntegerLiteralExpr; -import com.github.javaparser.ast.expr.IntegerLiteralMinValueExpr; -import com.github.javaparser.ast.expr.LambdaExpr; -import com.github.javaparser.ast.expr.LongLiteralExpr; -import com.github.javaparser.ast.expr.LongLiteralMinValueExpr; -import com.github.javaparser.ast.expr.MarkerAnnotationExpr; -import com.github.javaparser.ast.expr.MemberValuePair; -import com.github.javaparser.ast.expr.MethodCallExpr; -import com.github.javaparser.ast.expr.MethodReferenceExpr; -import com.github.javaparser.ast.expr.NameExpr; -import com.github.javaparser.ast.expr.NormalAnnotationExpr; -import com.github.javaparser.ast.expr.NullLiteralExpr; -import com.github.javaparser.ast.expr.ObjectCreationExpr; -import com.github.javaparser.ast.expr.QualifiedNameExpr; -import com.github.javaparser.ast.expr.SingleMemberAnnotationExpr; -import com.github.javaparser.ast.expr.StringLiteralExpr; -import com.github.javaparser.ast.expr.SuperExpr; -import com.github.javaparser.ast.expr.ThisExpr; -import com.github.javaparser.ast.expr.TypeExpr; -import com.github.javaparser.ast.expr.UnaryExpr; -import com.github.javaparser.ast.expr.VariableDeclarationExpr; +import com.github.javaparser.ast.expr.*; +import com.github.javaparser.ast.imports.*; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; -import com.github.javaparser.ast.stmt.AssertStmt; -import com.github.javaparser.ast.stmt.BlockStmt; -import com.github.javaparser.ast.stmt.BreakStmt; -import com.github.javaparser.ast.stmt.CatchClause; -import com.github.javaparser.ast.stmt.ContinueStmt; -import com.github.javaparser.ast.stmt.DoStmt; -import com.github.javaparser.ast.stmt.EmptyStmt; -import com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt; -import com.github.javaparser.ast.stmt.ExpressionStmt; -import com.github.javaparser.ast.stmt.ForStmt; -import com.github.javaparser.ast.stmt.ForeachStmt; -import com.github.javaparser.ast.stmt.IfStmt; -import com.github.javaparser.ast.stmt.LabeledStmt; -import com.github.javaparser.ast.stmt.ReturnStmt; -import com.github.javaparser.ast.stmt.Statement; -import com.github.javaparser.ast.stmt.SwitchEntryStmt; -import com.github.javaparser.ast.stmt.SwitchStmt; -import com.github.javaparser.ast.stmt.SynchronizedStmt; -import com.github.javaparser.ast.stmt.ThrowStmt; -import com.github.javaparser.ast.stmt.TryStmt; -import com.github.javaparser.ast.stmt.TypeDeclarationStmt; +import com.github.javaparser.ast.stmt.*; import com.github.javaparser.ast.type.*; -import com.github.javaparser.ast.stmt.WhileStmt; + +import java.util.List; + +import static com.github.javaparser.utils.Utils.option; /** * This visitor adapter can be used to save time when some specific nodes needs @@ -116,51 +45,22 @@ import com.github.javaparser.ast.stmt.WhileStmt; * @author Julio Vilmar Gesser */ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { - - private void removeNulls(final List<?> list) { - for (int i = list.size() - 1; i >= 0; i--) { - if (list.get(i) == null) { - list.remove(i); - } - } - } - - @Override public Node visit(final AnnotationDeclaration n, final A arg) { + @Override public Node visit(final AnnotationDeclaration n, final A arg) { visitAnnotations(n, arg); visitComment(n, arg); - final List<BodyDeclaration<?>> members = n.getMembers(); - if (members != null) { - for (int i = 0; i < members.size(); i++) { - members.set(i, (BodyDeclaration<?>) members.get(i).accept(this, arg)); - } - removeNulls(members); - } + n.setMembers((NodeList<BodyDeclaration<?>>) n.getMembers().accept(this, arg)); return n; } private void visitAnnotations(NodeWithAnnotations<?> n, A arg) { - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); } @Override public Node visit(final AnnotationMemberDeclaration n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); n.setType((Type) n.getType().accept(this, arg)); - if (n.getDefaultValue() != null) { - n.setDefaultValue((Expression) n.getDefaultValue().accept(this, arg)); - } + n.setDefaultValue(n.getDefaultValue().flatMap(dv -> option((Expression) dv.accept(this, arg)))); return n; } @@ -173,40 +73,22 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final ArrayCreationExpr n, final A arg) { visitComment(n, arg); - n.setType((Type) n.getType().accept(this, arg)); - - final List<ArrayCreationLevel> values = n.getLevels(); - for (int i = 0; i < values.size(); i++) { - values.set(i, (ArrayCreationLevel) values.get(i).accept(this, arg)); - } - removeNulls(values); - - if (n.getInitializer() != null) { - n.setInitializer((ArrayInitializerExpr) n.getInitializer().accept(this, arg)); - } + n.setElementType((Type) n.getElementType().accept(this, arg)); + n.setLevels((NodeList<ArrayCreationLevel>)n.getLevels().accept(this, arg)); + n.setInitializer(n.getInitializer().flatMap(dv -> option((ArrayInitializerExpr) dv.accept(this, arg)))); return n; } @Override public Node visit(final ArrayInitializerExpr n, final A arg) { visitComment(n, arg); - if (n.getValues() != null) { - final List<Expression> values = n.getValues(); - if (values != null) { - for (int i = 0; i < values.size(); i++) { - values.set(i, (Expression) values.get(i).accept(this, arg)); - } - removeNulls(values); - } - } + n.setValues((NodeList<Expression>)n.getValues().accept(this, arg)); return n; } @Override public Node visit(final AssertStmt n, final A arg) { visitComment(n, arg); n.setCheck((Expression) n.getCheck().accept(this, arg)); - if (n.getMessage() != null) { - n.setMessage((Expression) n.getMessage().accept(this, arg)); - } + n.setMessage(n.getMessage().flatMap(p -> option((Expression) p.accept(this, arg)))); return n; } @@ -244,13 +126,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final BlockStmt n, final A arg) { visitComment(n, arg); - final List<Statement> stmts = n.getStmts(); - if (stmts != null) { - for (int i = 0; i < stmts.size(); i++) { - stmts.set(i, (Statement) stmts.get(i).accept(this, arg)); - } - removeNulls(stmts); - } + n.setStmts((NodeList<Statement>) n.getStmts().accept(this, arg)); return n; } @@ -301,72 +177,33 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final ClassOrInterfaceDeclaration n, final A arg) { visitAnnotations(n, arg); visitComment(n, arg); - final List<TypeParameter> typeParameters = n.getTypeParameters(); - if (typeParameters != null) { - for (int i = 0; i < typeParameters.size(); i++) { - typeParameters.set(i, (TypeParameter) typeParameters.get(i).accept(this, arg)); - } - removeNulls(typeParameters); - } - final List<ClassOrInterfaceType> extendz = n.getExtends(); - if (extendz != null) { - for (int i = 0; i < extendz.size(); i++) { - extendz.set(i, (ClassOrInterfaceType) extendz.get(i).accept(this, arg)); - } - removeNulls(extendz); - } - final List<ClassOrInterfaceType> implementz = n.getImplements(); - if (implementz != null) { - for (int i = 0; i < implementz.size(); i++) { - implementz.set(i, (ClassOrInterfaceType) implementz.get(i).accept(this, arg)); - } - removeNulls(implementz); - } - final List<BodyDeclaration<?>> members = n.getMembers(); - if (members != null) { - for (int i = 0; i < members.size(); i++) { - members.set(i, (BodyDeclaration<?>) members.get(i).accept(this, arg)); - } - removeNulls(members); - } + n.setTypeParameters(modifyList(n.getTypeParameters(), arg)); + n.setExtends(modifyList(n.getExtends(), arg)); + n.setImplements(modifyList(n.getImplements(), arg)); + n.setMembers((NodeList<BodyDeclaration<?>>) n.getMembers().accept(this, arg)); return n; } - @Override public Node visit(final ClassOrInterfaceType n, final A arg) { + private <N extends Node> NodeList<N> modifyList(NodeList<N> list, A arg) { + if(list==null){ + return null; + } + return (NodeList<N>) list.accept(this, arg); + } + + @Override public Node visit(final ClassOrInterfaceType n, final A arg) { visitComment(n, arg); visitAnnotations(n, arg); - if (n.getScope() != null) { - n.setScope((ClassOrInterfaceType) n.getScope().accept(this, arg)); - } - final List<Type<?>> typeArguments = n.getTypeArguments(); - if (typeArguments != null) { - for (int i = 0; i < typeArguments.size(); i++) { - typeArguments.set(i, (Type<?>) typeArguments.get(i).accept(this, arg)); - } - removeNulls(typeArguments); - } + n.setScope(n.getScope().flatMap(p -> option((ClassOrInterfaceType) p.accept(this, arg)))); + n.setTypeArguments(n.getTypeArguments().flatMap(p -> option((NodeList<Type<?>>) modifyList(p, arg)))); return n; } @Override public Node visit(final CompilationUnit n, final A arg) { visitComment(n, arg); - if (n.getPackage() != null) { - n.setPackage((PackageDeclaration) n.getPackage().accept(this, arg)); - } - final List<ImportDeclaration> imports = n.getImports(); - if (imports != null) { - for (int i = 0; i < imports.size(); i++) { - imports.set(i, (ImportDeclaration) imports.get(i).accept(this, arg)); - } - removeNulls(imports); - } - final List<TypeDeclaration<?>> types = n.getTypes(); - if (types != null) { - for (int i = 0; i < types.size(); i++) { - types.set(i, (TypeDeclaration<?>) types.get(i).accept(this, arg)); - } - removeNulls(types); - } + n.setPackage(n.getPackage().flatMap(p -> option((PackageDeclaration) p.accept(this, arg)))); + n.setImports((NodeList<ImportDeclaration> )n.getImports().accept(this, arg)); + n.setTypes((NodeList<TypeDeclaration<?>> )n.getTypes().accept(this, arg)); return n; } @@ -380,34 +217,10 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final ConstructorDeclaration n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } - final List<TypeParameter> typeParameters = n.getTypeParameters(); - if (typeParameters != null) { - for (int i = 0; i < typeParameters.size(); i++) { - typeParameters.set(i, (TypeParameter) typeParameters.get(i).accept(this, arg)); - } - removeNulls(typeParameters); - } - final List<Parameter> parameters = n.getParameters(); - if (parameters != null) { - for (int i = 0; i < parameters.size(); i++) { - parameters.set(i, (Parameter) parameters.get(i).accept(this, arg)); - } - removeNulls(parameters); - } - final List<ReferenceType> throwz = n.getThrows(); - if (throwz != null) { - for (int i = 0; i < throwz.size(); i++) { - throwz.set(i, (ReferenceType) throwz.get(i).accept(this, arg)); - } - removeNulls(throwz); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); + n.setTypeParameters(modifyList(n.getTypeParameters(), arg)); + n.setParameters((NodeList<Parameter>)n.getParameters().accept(this, arg)); + n.setThrows((NodeList<ReferenceType<?>>)n.getThrows().accept(this, arg)); n.setBody((BlockStmt) n.getBody().accept(this, arg)); return n; } @@ -456,88 +269,34 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final EnclosedExpr n, final A arg) { visitComment(n, arg); - n.setInner((Expression) n.getInner().accept(this, arg)); + n.setInner(n.getInner().flatMap(p -> option((Expression) p.accept(this, arg)))); return n; } @Override public Node visit(final EnumConstantDeclaration n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } - final List<Expression> args = n.getArgs(); - if (args != null) { - for (int i = 0; i < args.size(); i++) { - args.set(i, (Expression) args.get(i).accept(this, arg)); - } - removeNulls(args); - } - final List<BodyDeclaration<?>> classBody = n.getClassBody(); - if (classBody != null) { - for (int i = 0; i < classBody.size(); i++) { - classBody.set(i, (BodyDeclaration<?>) classBody.get(i).accept(this, arg)); - } - removeNulls(classBody); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); + n.setArgs((NodeList<Expression>)n.getArgs().accept(this, arg)); + n.setClassBody((NodeList<BodyDeclaration<?>>)n.getClassBody().accept(this, arg)); return n; } @Override public Node visit(final EnumDeclaration n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } - final List<ClassOrInterfaceType> implementz = n.getImplements(); - if (implementz != null) { - for (int i = 0; i < implementz.size(); i++) { - implementz.set(i, (ClassOrInterfaceType) implementz.get(i).accept(this, arg)); - } - removeNulls(implementz); - } - final List<EnumConstantDeclaration> entries = n.getEntries(); - if (entries != null) { - for (int i = 0; i < entries.size(); i++) { - entries.set(i, (EnumConstantDeclaration) entries.get(i).accept(this, arg)); - } - removeNulls(entries); - } - final List<BodyDeclaration<?>> members = n.getMembers(); - if (members != null) { - for (int i = 0; i < members.size(); i++) { - members.set(i, (BodyDeclaration<?>) members.get(i).accept(this, arg)); - } - removeNulls(members); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); + n.setImplements((NodeList<ClassOrInterfaceType>) n.getImplements().accept(this, arg)); + n.setEntries((NodeList<EnumConstantDeclaration>)n.getEntries().accept(this, arg)); + n.setMembers((NodeList<BodyDeclaration<?>>) n.getMembers().accept(this, arg)); return n; } @Override public Node visit(final ExplicitConstructorInvocationStmt n, final A arg) { visitComment(n, arg); - if (!n.isThis() && n.getExpr() != null) { - n.setExpr((Expression) n.getExpr().accept(this, arg)); - } - final List<Type<?>> typeArguments = n.getTypeArguments(); - if (typeArguments != null) { - for (int i = 0; i < typeArguments.size(); i++) { - typeArguments.set(i, (Type<?>) typeArguments.get(i).accept(this, arg)); - } - removeNulls(typeArguments); - } - final List<Expression> args = n.getArgs(); - if (args != null) { - for (int i = 0; i < args.size(); i++) { - args.set(i, (Expression) args.get(i).accept(this, arg)); - } - removeNulls(args); + if (!n.isThis()) { + n.setExpr(n.getExpr().flatMap(p -> option((Expression) p.accept(this, arg)))); } + n.setTypeArguments(n.getTypeArguments().flatMap(p -> option((NodeList<Type<?>>) modifyList(p, arg)))); + n.setArgs((NodeList<Expression>)n.getArgs().accept(this, arg)); return n; } @@ -563,19 +322,9 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final FieldDeclaration n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); n.setElementType((Type) n.getElementType().accept(this, arg)); - final List<VariableDeclarator> variables = n.getVariables(); - for (int i = 0; i < variables.size(); i++) { - variables.set(i, (VariableDeclarator) variables.get(i).accept(this, arg)); - } - removeNulls(variables); + n.setVariables((NodeList<VariableDeclarator>)n.getVariables().accept(this, arg)); return n; } @@ -589,23 +338,9 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final ForStmt n, final A arg) { visitComment(n, arg); - final List<Expression> init = n.getInit(); - if (init != null) { - for (int i = 0; i < init.size(); i++) { - init.set(i, (Expression) init.get(i).accept(this, arg)); - } - removeNulls(init); - } - if (n.getCompare() != null) { - n.setCompare((Expression) n.getCompare().accept(this, arg)); - } - final List<Expression> update = n.getUpdate(); - if (update != null) { - for (int i = 0; i < update.size(); i++) { - update.set(i, (Expression) update.get(i).accept(this, arg)); - } - removeNulls(update); - } + n.setInit((NodeList<Expression>)n.getInit().accept(this, arg)); + n.setCompare(n.getCompare().flatMap(p -> option((Expression) p.accept(this, arg)))); + n.setUpdate((NodeList<Expression>)n.getUpdate().accept(this, arg)); n.setBody((Statement) n.getBody().accept(this, arg)); return n; } @@ -626,9 +361,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { return null; } n.setThenStmt(thenStmt); - if (n.getElseStmt() != null) { - n.setElseStmt((Statement) n.getElseStmt().accept(this, arg)); - } + n.setElseStmt(n.getElseStmt().flatMap(p -> option((Statement) p.accept(this, arg)))); return n; } @@ -641,7 +374,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final InstanceOfExpr n, final A arg) { visitComment(n, arg); n.setExpr((Expression) n.getExpr().accept(this, arg)); - n.setType((Type) n.getType().accept(this, arg)); + n.setType((ReferenceType<?>) n.getType().accept(this, arg)); return n; } @@ -689,60 +422,20 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final MethodCallExpr n, final A arg) { visitComment(n, arg); - if (n.getScope() != null) { - n.setScope((Expression) n.getScope().accept(this, arg)); - } - final List<Type<?>> typeArguments = n.getTypeArguments(); - if (typeArguments != null) { - for (int i = 0; i < typeArguments.size(); i++) { - typeArguments.set(i, (Type<?>) typeArguments.get(i).accept(this, arg)); - } - removeNulls(typeArguments); - } - final List<Expression> args = n.getArgs(); - if (args != null) { - for (int i = 0; i < args.size(); i++) { - args.set(i, (Expression) args.get(i).accept(this, arg)); - } - removeNulls(args); - } + n.setScope(n.getScope().flatMap(p -> option((Expression) p.accept(this, arg)))); + n.setTypeArguments(n.getTypeArguments().flatMap(p -> option((NodeList<Type<?>>) modifyList(p, arg)))); + n.setArgs((NodeList<Expression>)n.getArgs().accept(this, arg)); return n; } @Override public Node visit(final MethodDeclaration n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } - final List<TypeParameter> typeParameters = n.getTypeParameters(); - if (typeParameters != null) { - for (int i = 0; i < typeParameters.size(); i++) { - typeParameters.set(i, (TypeParameter) typeParameters.get(i).accept(this, arg)); - } - removeNulls(typeParameters); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); + n.setTypeParameters(modifyList(n.getTypeParameters(), arg)); n.setElementType((Type) n.getElementType().accept(this, arg)); - final List<Parameter> parameters = n.getParameters(); - if (parameters != null) { - for (int i = 0; i < parameters.size(); i++) { - parameters.set(i, (Parameter) parameters.get(i).accept(this, arg)); - } - removeNulls(parameters); - } - final List<ReferenceType> throwz = n.getThrows(); - if (throwz != null) { - for (int i = 0; i < throwz.size(); i++) { - throwz.set(i, (ReferenceType) throwz.get(i).accept(this, arg)); - } - removeNulls(throwz); - } - if (n.getBody() != null) { - n.setBody((BlockStmt) n.getBody().accept(this, arg)); - } + n.setParameters((NodeList<Parameter>)n.getParameters().accept(this, arg)); + n.setThrows((NodeList<ReferenceType<?>>)n.getThrows().accept(this, arg)); + n.setBody(n.getBody().flatMap(p -> option((BlockStmt) p.accept(this, arg)))); return n; } @@ -754,13 +447,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final NormalAnnotationExpr n, final A arg) { visitComment(n, arg); n.setName((NameExpr) n.getName().accept(this, arg)); - final List<MemberValuePair> pairs = n.getPairs(); - if (pairs != null) { - for (int i = 0; i < pairs.size(); i++) { - pairs.set(i, (MemberValuePair) pairs.get(i).accept(this, arg)); - } - removeNulls(pairs); - } + n.setPairs((NodeList<MemberValuePair>)n.getPairs().accept(this, arg)); return n; } @@ -771,43 +458,17 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final ObjectCreationExpr n, final A arg) { visitComment(n, arg); - if (n.getScope() != null) { - n.setScope((Expression) n.getScope().accept(this, arg)); - } - final List<Type<?>> typeArguments = n.getTypeArguments(); - if (typeArguments != null) { - for (int i = 0; i < typeArguments.size(); i++) { - typeArguments.set(i, (Type<?>) typeArguments.get(i).accept(this, arg)); - } - removeNulls(typeArguments); - } + n.setScope(n.getScope().flatMap(p -> option((Expression) p.accept(this, arg)))); + n.setTypeArguments(n.getTypeArguments().flatMap(p -> option((NodeList<Type<?>>) modifyList(p, arg)))); n.setType((ClassOrInterfaceType) n.getType().accept(this, arg)); - final List<Expression> args = n.getArgs(); - if (args != null) { - for (int i = 0; i < args.size(); i++) { - args.set(i, (Expression) args.get(i).accept(this, arg)); - } - removeNulls(args); - } - final List<BodyDeclaration<?>> anonymousClassBody = n.getAnonymousClassBody(); - if (anonymousClassBody != null) { - for (int i = 0; i < anonymousClassBody.size(); i++) { - anonymousClassBody.set(i, (BodyDeclaration<?>) anonymousClassBody.get(i).accept(this, arg)); - } - removeNulls(anonymousClassBody); - } + n.setArgs((NodeList<Expression>)n.getArgs().accept(this, arg)); + n.setAnonymousClassBody(n.getAnonymousClassBody().flatMap(p -> option((NodeList<BodyDeclaration<?>>) p.accept(this, arg)))); return n; } @Override public Node visit(final PackageDeclaration n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); n.setName((NameExpr) n.getName().accept(this, arg)); return n; } @@ -844,9 +505,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { public Node visit(ArrayCreationLevel n, A arg) { visitComment(n, arg); visitAnnotations(n, arg); - if(n.getDimension()!=null) { - n.setDimension((Expression) n.getDimension().accept(this, arg)); - } + n.setDimension(n.getDimension().flatMap(p -> option((Expression) p.accept(this, arg)))); return n; } @@ -854,13 +513,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { public Node visit(final IntersectionType n, final A arg) { visitComment(n, arg); visitAnnotations(n, arg); - final List<ReferenceType> elements = n.getElements(); - if (elements != null) { - for (int i = 0; i < elements.size(); i++) { - elements.set(i, (ReferenceType) elements.get(i).accept(this, arg)); - } - removeNulls(elements); - } + n.setElements((NodeList<ReferenceType<?>>)n.getElements().accept(this, arg)); return n; } @@ -868,21 +521,13 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { public Node visit(final UnionType n, final A arg) { visitComment(n, arg); visitAnnotations(n, arg); - final List<ReferenceType> elements = n.getElements(); - if (elements != null) { - for (int i = 0; i < elements.size(); i++) { - elements.set(i, (ReferenceType) elements.get(i).accept(this, arg)); - } - removeNulls(elements); - } + n.setElements((NodeList<ReferenceType<?>>)n.getElements().accept(this, arg)); return n; } @Override public Node visit(final ReturnStmt n, final A arg) { visitComment(n, arg); - if (n.getExpr() != null) { - n.setExpr((Expression) n.getExpr().accept(this, arg)); - } + n.setExpr(n.getExpr().flatMap(p -> option((Expression) p.accept(this, arg)))); return n; } @@ -900,37 +545,21 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final SuperExpr n, final A arg) { visitComment(n, arg); - if (n.getClassExpr() != null) { - n.setClassExpr((Expression) n.getClassExpr().accept(this, arg)); - } + n.setClassExpr(n.getClassExpr().flatMap(p -> option((Expression) p.accept(this, arg)))); return n; } @Override public Node visit(final SwitchEntryStmt n, final A arg) { visitComment(n, arg); - if (n.getLabel() != null) { - n.setLabel((Expression) n.getLabel().accept(this, arg)); - } - final List<Statement> stmts = n.getStmts(); - if (stmts != null) { - for (int i = 0; i < stmts.size(); i++) { - stmts.set(i, (Statement) stmts.get(i).accept(this, arg)); - } - removeNulls(stmts); - } + n.setLabel(n.getLabel().flatMap(p -> option((Expression) p.accept(this, arg)))); + n.setStmts((NodeList<Statement>) n.getStmts().accept(this, arg)); return n; } @Override public Node visit(final SwitchStmt n, final A arg) { visitComment(n, arg); n.setSelector((Expression) n.getSelector().accept(this, arg)); - final List<SwitchEntryStmt> entries = n.getEntries(); - if (entries != null) { - for (int i = 0; i < entries.size(); i++) { - entries.set(i, (SwitchEntryStmt) entries.get(i).accept(this, arg)); - } - removeNulls(entries); - } + n.setEntries((NodeList<SwitchEntryStmt>)n.getEntries().accept(this, arg)); return n; } @@ -944,9 +573,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final ThisExpr n, final A arg) { visitComment(n, arg); - if (n.getClassExpr() != null) { - n.setClassExpr((Expression) n.getClassExpr().accept(this, arg)); - } + n.setClassExpr(n.getClassExpr().flatMap(p -> option((Expression) p.accept(this, arg)))); return n; } @@ -958,22 +585,10 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final TryStmt n, final A arg) { visitComment(n, arg); - final List<VariableDeclarationExpr> types = n.getResources(); - for (int i = 0; i < types.size(); i++) { - n.getResources().set(i, - (VariableDeclarationExpr) n.getResources().get(i).accept(this, arg)); - } + n.setResources((NodeList<VariableDeclarationExpr>)n.getResources().accept(this, arg)); n.setTryBlock((BlockStmt) n.getTryBlock().accept(this, arg)); - final List<CatchClause> catchs = n.getCatchs(); - if (catchs != null) { - for (int i = 0; i < catchs.size(); i++) { - catchs.set(i, (CatchClause) catchs.get(i).accept(this, arg)); - } - removeNulls(catchs); - } - if (n.getFinallyBlock() != null) { - n.setFinallyBlock((BlockStmt) n.getFinallyBlock().accept(this, arg)); - } + n.setCatchs((NodeList<CatchClause>)n.getCatchs().accept(this, arg)); + n.setFinallyBlock(n.getFinallyBlock().flatMap(p -> option((BlockStmt) p.accept(this, arg)))); return n; } @@ -985,13 +600,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final TypeParameter n, final A arg) { visitComment(n, arg); - final List<ClassOrInterfaceType> typeBound = n.getTypeBound(); - if (typeBound != null) { - for (int i = 0; i < typeBound.size(); i++) { - typeBound.set(i, (ClassOrInterfaceType) typeBound.get(i).accept(this, arg)); - } - removeNulls(typeBound); - } + n.setTypeBound((NodeList<ClassOrInterfaceType>)n.getTypeBound().accept(this, arg)); return n; } @@ -1008,13 +617,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final VariableDeclarationExpr n, final A arg) { visitComment(n, arg); - final List<AnnotationExpr> annotations = n.getAnnotations(); - if (annotations != null) { - for (int i = 0; i < annotations.size(); i++) { - annotations.set(i, (AnnotationExpr) annotations.get(i).accept(this, arg)); - } - removeNulls(annotations); - } + n.setAnnotations((NodeList<AnnotationExpr>)n.getAnnotations().accept(this, arg)); final Type type = (Type) n.getElementType().accept(this, arg); if (type == null) { @@ -1022,19 +625,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { } n.setElementType(type); - final List<VariableDeclarator> vars = n.getVariables(); - for (int i = 0; i < vars.size();) { - final VariableDeclarator decl = (VariableDeclarator) - vars.get(i).accept(this, arg); - if (decl == null) { - vars.remove(i); - } else { - vars.set(i++, decl); - } - } - if (vars.isEmpty()) { - return null; - } + n.setVariables((NodeList<VariableDeclarator>)n.getVariables().accept(this, arg)); return n; } @@ -1047,9 +638,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { return null; } n.setId(id); - if (n.getInit() != null) { - n.setInit((Expression) n.getInit().accept(this, arg)); - } + n.setInit(n.getInit().flatMap(p -> option((Expression) p.accept(this, arg)))); return n; } @@ -1074,23 +663,15 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final WildcardType n, final A arg) { visitComment(n, arg); visitAnnotations(n, arg); - if (n.getExtends() != null) { - n.setExtends((ReferenceType) n.getExtends().accept(this, arg)); - } - if (n.getSuper() != null) { - n.setSuper((ReferenceType) n.getSuper().accept(this, arg)); - } + n.setExtends(n.getExtends().flatMap(p -> option((ReferenceType<?>) p.accept(this, arg)))); + n.setSuper(n.getSuper().flatMap(p -> option((ReferenceType<?>) p.accept(this, arg)))); return n; } @Override public Node visit(final LambdaExpr n, final A arg) { visitComment(n, arg); - final List<Parameter> parameters = n.getParameters(); - for (int i = 0; i < parameters.size(); i++) { - parameters.set(i, (Parameter) parameters.get(i).accept(this, arg)); - } - removeNulls(parameters); + n.setParameters((NodeList<Parameter>)n.getParameters().accept(this, arg)); if (n.getBody() != null) { n.setBody((Statement) n.getBody().accept(this, arg)); } @@ -1100,11 +681,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { @Override public Node visit(final MethodReferenceExpr n, final A arg) { visitComment(n, arg); - final List<Type<?>> types = n.getTypeArguments(); - for (int i = 0; i < types.size(); i++) { - n.getTypeArguments().set(i, - (Type<?>) n.getTypeArguments().get(i).accept(this, arg)); - } + n.setTypeArguments(n.getTypeArguments().flatMap(p -> option((NodeList<Type<?>>) modifyList(p, arg)))); if (n.getScope() != null) { n.setScope((Expression)n.getScope().accept(this, arg)); } @@ -1126,6 +703,19 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { return n; } + @Override + public Node visit(NodeList n, A arg) { + for (int i = 0; i < n.size(); i++) { + n.set(i, n.get(i).accept(this, arg)); + } + for (int i = n.size() - 1; i >= 0; i--) { + if (n.get(i) == null) { + n.remove(i); + } + } + return n; + } + @Override public Node visit(EmptyImportDeclaration n, A arg) { visitComment(n, arg); @@ -1171,8 +761,7 @@ public class ModifierVisitorAdapter<A> implements GenericVisitor<Node, A> { } private void visitComment(Node n, final A arg) { - if (n != null && n.getComment() != null) { - n.setComment((Comment) n.getComment().accept(this, arg)); - } + if(n!=null) + n.setComment(n.getComment().flatMap(dv -> option((Comment) dv.accept(this, arg)))); } } diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitor.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitor.java index 30443a37b..7a6591546 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitor.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitor.java @@ -252,7 +252,9 @@ public interface VoidVisitor<A> { void visit(TypeExpr n, A arg); - void visit(ArrayBracketPair n, A arg); + void visit(ArrayBracketPair arrayBracketPair, A arg); + + void visit(NodeList n, A arg); void visit(EmptyImportDeclaration n, A arg); diff --git a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitorAdapter.java b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitorAdapter.java index d3335287f..affb2efdc 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitorAdapter.java +++ b/javaparser-core/src/main/java/com/github/javaparser/ast/visitor/VoidVisitorAdapter.java @@ -22,69 +22,19 @@ package com.github.javaparser.ast.visitor; import com.github.javaparser.ast.*; -import com.github.javaparser.ast.imports.*; -import com.github.javaparser.ast.stmt.*; -import com.github.javaparser.ast.type.TypeParameter; -import com.github.javaparser.ast.body.AnnotationDeclaration; -import com.github.javaparser.ast.body.AnnotationMemberDeclaration; -import com.github.javaparser.ast.body.BodyDeclaration; -import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; -import com.github.javaparser.ast.body.ConstructorDeclaration; -import com.github.javaparser.ast.body.EmptyMemberDeclaration; -import com.github.javaparser.ast.body.EmptyTypeDeclaration; -import com.github.javaparser.ast.body.EnumConstantDeclaration; -import com.github.javaparser.ast.body.EnumDeclaration; -import com.github.javaparser.ast.body.FieldDeclaration; -import com.github.javaparser.ast.body.InitializerDeclaration; -import com.github.javaparser.ast.body.MethodDeclaration; -import com.github.javaparser.ast.body.Parameter; -import com.github.javaparser.ast.body.TypeDeclaration; -import com.github.javaparser.ast.body.VariableDeclarator; -import com.github.javaparser.ast.body.VariableDeclaratorId; +import com.github.javaparser.ast.body.*; import com.github.javaparser.ast.comments.BlockComment; import com.github.javaparser.ast.comments.Comment; import com.github.javaparser.ast.comments.JavadocComment; import com.github.javaparser.ast.comments.LineComment; -import com.github.javaparser.ast.expr.AnnotationExpr; -import com.github.javaparser.ast.expr.ArrayAccessExpr; -import com.github.javaparser.ast.expr.ArrayCreationExpr; -import com.github.javaparser.ast.expr.ArrayInitializerExpr; -import com.github.javaparser.ast.expr.AssignExpr; -import com.github.javaparser.ast.expr.BinaryExpr; -import com.github.javaparser.ast.expr.BooleanLiteralExpr; -import com.github.javaparser.ast.expr.CastExpr; -import com.github.javaparser.ast.expr.CharLiteralExpr; -import com.github.javaparser.ast.expr.ClassExpr; -import com.github.javaparser.ast.expr.ConditionalExpr; -import com.github.javaparser.ast.expr.DoubleLiteralExpr; -import com.github.javaparser.ast.expr.EnclosedExpr; -import com.github.javaparser.ast.expr.Expression; -import com.github.javaparser.ast.expr.FieldAccessExpr; -import com.github.javaparser.ast.expr.InstanceOfExpr; -import com.github.javaparser.ast.expr.IntegerLiteralExpr; -import com.github.javaparser.ast.expr.IntegerLiteralMinValueExpr; -import com.github.javaparser.ast.expr.LambdaExpr; -import com.github.javaparser.ast.expr.LongLiteralExpr; -import com.github.javaparser.ast.expr.LongLiteralMinValueExpr; -import com.github.javaparser.ast.expr.MarkerAnnotationExpr; -import com.github.javaparser.ast.expr.MemberValuePair; -import com.github.javaparser.ast.expr.MethodCallExpr; -import com.github.javaparser.ast.expr.MethodReferenceExpr; -import com.github.javaparser.ast.expr.NameExpr; -import com.github.javaparser.ast.expr.NormalAnnotationExpr; -import com.github.javaparser.ast.expr.NullLiteralExpr; -import com.github.javaparser.ast.expr.ObjectCreationExpr; -import com.github.javaparser.ast.expr.QualifiedNameExpr; -import com.github.javaparser.ast.expr.SingleMemberAnnotationExpr; -import com.github.javaparser.ast.expr.StringLiteralExpr; -import com.github.javaparser.ast.expr.SuperExpr; -import com.github.javaparser.ast.expr.ThisExpr; -import com.github.javaparser.ast.expr.TypeExpr; -import com.github.javaparser.ast.expr.UnaryExpr; -import com.github.javaparser.ast.expr.VariableDeclarationExpr; +import com.github.javaparser.ast.expr.*; +import com.github.javaparser.ast.imports.*; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; +import com.github.javaparser.ast.stmt.*; import com.github.javaparser.ast.type.*; +import java.util.Optional; + /** * @author Julio Vilmar Gesser */ @@ -105,9 +55,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { visitComment(n.getComment(), arg); visitAnnotations(n, arg); n.getType().accept(this, arg); - if (n.getDefaultValue() != null) { - n.getDefaultValue().accept(this, arg); - } + n.getDefaultValue().ifPresent(d -> d.accept(this, arg)); } @Override public void visit(final ArrayAccessExpr n, final A arg) { @@ -118,13 +66,11 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final ArrayCreationExpr n, final A arg) { visitComment(n.getComment(), arg); - n.getType().accept(this, arg); + n.getElementType().accept(this, arg); for (ArrayCreationLevel level : n.getLevels()) { level.accept(this, arg); } - if (n.getInitializer() != null) { - n.getInitializer().accept(this, arg); - } + n.getInitializer().ifPresent(i -> i.accept(this, arg)); } @Override public void visit(final ArrayInitializerExpr n, final A arg) { @@ -139,9 +85,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final AssertStmt n, final A arg) { visitComment(n.getComment(), arg); n.getCheck().accept(this, arg); - if (n.getMessage() != null) { - n.getMessage().accept(this, arg); - } + n.getMessage().ifPresent(m-> m.accept(this, arg)); } @Override public void visit(final AssignExpr n, final A arg) { @@ -218,21 +162,13 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final ClassOrInterfaceType n, final A arg) { visitComment(n.getComment(), arg); visitAnnotations(n, arg); - if (n.getScope() != null) { - n.getScope().accept(this, arg); - } - if (n.getTypeArguments() != null) { - for (final Type t : n.getTypeArguments()) { - t.accept(this, arg); - } - } - } + n.getScope().ifPresent(s -> s.accept(this, arg)); + n.getTypeArguments().ifPresent(tas -> tas.forEach(ta -> ta.accept(this, arg))); + } @Override public void visit(final CompilationUnit n, final A arg) { visitComment(n.getComment(), arg); - if (n.getPackage() != null) { - n.getPackage().accept(this, arg); - } + n.getPackage().ifPresent(p -> p.accept(this, arg)); if (n.getImports() != null) { for (final ImportDeclaration i : n.getImports()) { i.accept(this, arg); @@ -303,7 +239,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final EnclosedExpr n, final A arg) { visitComment(n.getComment(), arg); - n.getInner().accept(this, arg); + n.getInner().ifPresent(i->i.accept(this, arg)); } @Override public void visit(final EnumConstantDeclaration n, final A arg) { @@ -344,14 +280,10 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final ExplicitConstructorInvocationStmt n, final A arg) { visitComment(n.getComment(), arg); - if (!n.isThis() && n.getExpr() != null) { - n.getExpr().accept(this, arg); - } - if (n.getTypeArguments() != null) { - for (final Type t : n.getTypeArguments()) { - t.accept(this, arg); - } + if (!n.isThis() && n.getExpr().isPresent()) { + n.getExpr().get().accept(this, arg); } + n.getTypeArguments().ifPresent(tas -> tas.forEach(ta -> ta.accept(this, arg))); if (n.getArgs() != null) { for (final Expression e : n.getArgs()) { e.accept(this, arg); @@ -388,19 +320,13 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final ForStmt n, final A arg) { visitComment(n.getComment(), arg); - if (n.getInit() != null) { - for (final Expression e : n.getInit()) { - e.accept(this, arg); - } - } - if (n.getCompare() != null) { - n.getCompare().accept(this, arg); - } - if (n.getUpdate() != null) { - for (final Expression e : n.getUpdate()) { - e.accept(this, arg); - } - } + for (final Expression e : n.getInit()) { + e.accept(this, arg); + } + n.getCompare().ifPresent(c-> c.accept(this, arg)); + for (final Expression e : n.getUpdate()) { + e.accept(this, arg); + } n.getBody().accept(this, arg); } @@ -408,10 +334,8 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { visitComment(n.getComment(), arg); n.getCondition().accept(this, arg); n.getThenStmt().accept(this, arg); - if (n.getElseStmt() != null) { - n.getElseStmt().accept(this, arg); - } - } + n.getElseStmt().ifPresent(es -> es.accept(this, arg)); + } @Override public void visit(final InitializerDeclaration n, final A arg) { visitComment(n.getComment(), arg); @@ -463,14 +387,8 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final MethodCallExpr n, final A arg) { visitComment(n.getComment(), arg); - if (n.getScope() != null) { - n.getScope().accept(this, arg); - } - if (n.getTypeArguments() != null) { - for (final Type t : n.getTypeArguments()) { - t.accept(this, arg); - } - } + n.getScope().ifPresent(s -> s.accept(this, arg)); + n.getTypeArguments().ifPresent(tas -> tas.forEach(ta -> ta.accept(this, arg))); n.getNameExpr().accept(this, arg); if (n.getArgs() != null) { for (final Expression e : n.getArgs()) { @@ -499,9 +417,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { name.accept(this, arg); } } - if (n.getBody() != null) { - n.getBody().accept(this, arg); - } + n.getBody().ifPresent(b -> b.accept(this, arg)); } @Override public void visit(final NameExpr n, final A arg) { @@ -524,26 +440,16 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final ObjectCreationExpr n, final A arg) { visitComment(n.getComment(), arg); - if (n.getScope() != null) { - n.getScope().accept(this, arg); - } - if (n.getTypeArguments() != null) { - for (final Type t : n.getTypeArguments()) { - t.accept(this, arg); - } - } + n.getScope().ifPresent(s->s.accept(this, arg)); + n.getTypeArguments().ifPresent(tas -> tas.forEach(ta -> ta.accept(this, arg))); n.getType().accept(this, arg); if (n.getArgs() != null) { for (final Expression e : n.getArgs()) { e.accept(this, arg); } } - if (n.getAnonymousClassBody() != null) { - for (final BodyDeclaration<?> member : n.getAnonymousClassBody()) { - member.accept(this, arg); - } - } - } + n.getAnonymousClassBody().ifPresent(acb -> acb.forEach(m -> m.accept(this, arg))); + } @Override public void visit(final PackageDeclaration n, final A arg) { visitComment(n.getComment(), arg); @@ -579,9 +485,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { public void visit(ArrayCreationLevel n, A arg) { visitComment(n.getComment(), arg); visitAnnotations(n, arg); - if(n.getDimension()!=null) { - n.getDimension().accept(this, arg); - } + n.getDimension().ifPresent(d -> d.accept(this, arg)); } @Override public void visit(final IntersectionType n, final A arg) { @@ -602,9 +506,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final ReturnStmt n, final A arg) { visitComment(n.getComment(), arg); - if (n.getExpr() != null) { - n.getExpr().accept(this, arg); - } + n.getExpr().ifPresent(e -> e.accept(this, arg)); } @Override public void visit(final SingleMemberAnnotationExpr n, final A arg) { @@ -619,16 +521,12 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final SuperExpr n, final A arg) { visitComment(n.getComment(), arg); - if (n.getClassExpr() != null) { - n.getClassExpr().accept(this, arg); - } - } + n.getClassExpr().ifPresent(ce -> ce.accept(this, arg)); + } @Override public void visit(final SwitchEntryStmt n, final A arg) { visitComment(n.getComment(), arg); - if (n.getLabel() != null) { - n.getLabel().accept(this, arg); - } + n.getLabel().ifPresent(l -> l.accept(this, arg)); if (n.getStmts() != null) { for (final Statement s : n.getStmts()) { s.accept(this, arg); @@ -654,9 +552,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final ThisExpr n, final A arg) { visitComment(n.getComment(), arg); - if (n.getClassExpr() != null) { - n.getClassExpr().accept(this, arg); - } + n.getClassExpr().ifPresent(ce-> ce.accept(this, arg)); } @Override public void visit(final ThrowStmt n, final A arg) { @@ -666,20 +562,16 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final TryStmt n, final A arg) { visitComment(n.getComment(), arg); - if (n.getResources() != null) { - for (final VariableDeclarationExpr v : n.getResources()) { - v.accept(this, arg); - } - } + for (final VariableDeclarationExpr v : n.getResources()) { + v.accept(this, arg); + } n.getTryBlock().accept(this, arg); if (n.getCatchs() != null) { for (final CatchClause c : n.getCatchs()) { c.accept(this, arg); } } - if (n.getFinallyBlock() != null) { - n.getFinallyBlock().accept(this, arg); - } + n.getFinallyBlock().ifPresent(f->f.accept(this, arg)); } @Override public void visit(final TypeDeclarationStmt n, final A arg) { @@ -717,9 +609,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final VariableDeclarator n, final A arg) { visitComment(n.getComment(), arg); n.getId().accept(this, arg); - if (n.getInit() != null) { - n.getInit().accept(this, arg); - } + n.getInit().ifPresent(i -> i.accept(this, arg)); } @Override public void visit(final VariableDeclaratorId n, final A arg) { @@ -741,13 +631,9 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(final WildcardType n, final A arg) { visitComment(n.getComment(), arg); visitAnnotations(n, arg); - if (n.getExtends() != null) { - n.getExtends().accept(this, arg); - } - if (n.getSuper() != null) { - n.getSuper().accept(this, arg); - } - } + n.getExtends().ifPresent(e -> e.accept(this, arg)); + n.getSuper().ifPresent(s -> s.accept(this, arg)); + } @Override public void visit(LambdaExpr n, final A arg) { @@ -765,11 +651,7 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { @Override public void visit(MethodReferenceExpr n, final A arg) { visitComment(n.getComment(), arg); - if (n.getTypeArguments() != null) { - for (final Type t : n.getTypeArguments()) { - t.accept(this, arg); - } - } + n.getTypeArguments().ifPresent(tas -> tas.forEach(ta -> ta.accept(this, arg))); if (n.getScope() != null) { n.getScope().accept(this, arg); } @@ -789,6 +671,13 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { } @Override + public void visit(NodeList n, A arg) { + for(Object node: n){ + ((Node)node).accept(this, arg); + } + } + + @Override public void visit(EmptyImportDeclaration n, A arg) { visitComment(n.getComment(), arg); @@ -818,10 +707,8 @@ public abstract class VoidVisitorAdapter<A> implements VoidVisitor<A> { n.getName().accept(this, arg); } - private void visitComment(final Comment n, final A arg) { - if (n != null) { - n.accept(this, arg); - } + private void visitComment(final Optional<? extends Comment> n, final A arg) { + n.ifPresent(c -> c.accept(this, arg)); } private void visitAnnotations(NodeWithAnnotations<?> n, A arg) { diff --git a/javaparser-core/src/main/java/com/github/javaparser/utils/PositionUtils.java b/javaparser-core/src/main/java/com/github/javaparser/utils/PositionUtils.java index e1ecf190e..d0c7041e7 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/utils/PositionUtils.java +++ b/javaparser-core/src/main/java/com/github/javaparser/utils/PositionUtils.java @@ -24,17 +24,16 @@ package com.github.javaparser.utils; import static java.lang.Integer.signum; import java.util.Collections; -import java.util.LinkedList; import java.util.List; import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.NodeList; import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration; import com.github.javaparser.ast.body.FieldDeclaration; import com.github.javaparser.ast.body.MethodDeclaration; import com.github.javaparser.ast.expr.AnnotationExpr; import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations; import com.github.javaparser.ast.nodeTypes.NodeWithElementType; -import com.github.javaparser.ast.nodeTypes.NodeWithType; public final class PositionUtils { @@ -46,10 +45,18 @@ public final class PositionUtils { sortByBeginPosition(nodes, false); } + public static <T extends Node> void sortByBeginPosition(NodeList<T> nodes){ + sortByBeginPosition(nodes, false); + } + public static <T extends Node> void sortByBeginPosition(List<T> nodes, final boolean ignoringAnnotations){ Collections.sort(nodes, (o1, o2) -> PositionUtils.compare(o1, o2, ignoringAnnotations)); } + public static <T extends Node> void sortByBeginPosition(NodeList<T> nodes, final boolean ignoringAnnotations){ + nodes.sort((o1, o2) -> PositionUtils.compare(o1, o2, ignoringAnnotations)); + } + public static boolean areInOrder(Node a, Node b){ return areInOrder(a, b, false); } @@ -78,8 +85,7 @@ public final class PositionUtils { public static AnnotationExpr getLastAnnotation(Node node) { if (node instanceof NodeWithAnnotations){ - List<AnnotationExpr> annotations = new LinkedList<>(); - annotations.addAll(((NodeWithAnnotations<?>) node).getAnnotations()); + NodeList<AnnotationExpr> annotations = NodeList.nodeList(((NodeWithAnnotations<?>) node).getAnnotations()); if (annotations.isEmpty()){ return null; } @@ -113,9 +119,9 @@ public final class PositionUtils { public static boolean nodeContains(Node container, Node contained, boolean ignoringAnnotations){ if (!ignoringAnnotations || PositionUtils.getLastAnnotation(container)==null){ - return container.contains(contained); + return container.containsWithin(contained); } - if (!container.contains(contained)){ + if (!container.containsWithin(contained)){ return false; } // if the node is contained, but it comes immediately after the annotations, diff --git a/javaparser-core/src/main/java/com/github/javaparser/utils/Utils.java b/javaparser-core/src/main/java/com/github/javaparser/utils/Utils.java index b9320852d..97f074127 100644 --- a/javaparser-core/src/main/java/com/github/javaparser/utils/Utils.java +++ b/javaparser-core/src/main/java/com/github/javaparser/utils/Utils.java @@ -21,9 +21,6 @@ package com.github.javaparser.utils; -import com.github.javaparser.Provider; - -import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.Reader; import java.util.*; @@ -35,17 +32,10 @@ import java.util.*; */ public class Utils { public static final String EOL = System.getProperty("line.separator"); - public static <T> List<T> ensureNotNull(List<T> list) { - return list == null ? new ArrayList<T>() : list; - } - - public static <E> boolean isNullOrEmpty(Collection<E> collection) { - return collection == null || collection.isEmpty(); - } public static <T> T assertNotNull(T o) { if (o == null) { - throw new NullPointerException("Assertion failed."); + throw new AssertionError("A reference was unexpectedly null."); } return o; } @@ -82,21 +72,9 @@ public class Utils { return result.toString(); } - public static String providerToString(Provider provider) throws IOException { - final StringBuilder result = new StringBuilder(); - final char[] buffer = new char[8 * 1024]; - int numChars; - - while ((numChars = provider.read(buffer, 0, buffer.length)) != -1) { - result.append(buffer, 0, numChars); - } - - return result.toString(); - } - /** * Puts varargs in a mutable list. - * This does not have the disadvantage of Arrays#asList that it has a static size. + * This does not have the disadvantage of Arrays#asList that it has a static size. */ public static <T> List<T> arrayToList(T[] array){ List<T> list = new LinkedList<>(); @@ -104,4 +82,24 @@ public class Utils { return list; } + /** + * Scala-like statically importable shortcut to Optional.of + */ + public static <T> Optional<T> some(T t) { + return Optional.of(t); + } + + /** + * Importable shortcut to Optional.ofNullable + */ + public static <T> Optional<T> option(T t) { + return Optional.ofNullable(t); + } + + /** + * Scala-like importable shortcut to Optional.empty() + */ + public static <T> Optional<T> none() { + return Optional.empty(); + } } |