diff options
Diffstat (limited to 'javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/ASTHelper.java')
| -rw-r--r-- | javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/ASTHelper.java | 297 |
1 files changed, 297 insertions, 0 deletions
diff --git a/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/ASTHelper.java b/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/ASTHelper.java new file mode 100644 index 000000000..7e706cd64 --- /dev/null +++ b/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/ASTHelper.java @@ -0,0 +1,297 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2015 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ + +package com.github.javaparser; + +import com.github.javaparser.ast.CompilationUnit; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.body.BodyDeclaration; +import com.github.javaparser.ast.body.FieldDeclaration; +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.expr.Expression; +import com.github.javaparser.ast.expr.MethodCallExpr; +import com.github.javaparser.ast.expr.NameExpr; +import com.github.javaparser.ast.expr.QualifiedNameExpr; +import com.github.javaparser.ast.expr.VariableDeclarationExpr; +import com.github.javaparser.ast.stmt.BlockStmt; +import com.github.javaparser.ast.stmt.ExpressionStmt; +import com.github.javaparser.ast.stmt.Statement; +import com.github.javaparser.ast.type.ClassOrInterfaceType; +import com.github.javaparser.ast.type.PrimitiveType; +import com.github.javaparser.ast.type.ReferenceType; +import com.github.javaparser.ast.type.Type; +import com.github.javaparser.ast.type.VoidType; +import com.github.javaparser.ast.type.PrimitiveType.Primitive; + +import java.util.ArrayList; +import java.util.List; + +/** + * This class helps to construct new nodes. + * + * @author Júlio Vilmar Gesser + */ +public final class ASTHelper { + + public static final PrimitiveType BYTE_TYPE = new PrimitiveType(Primitive.Byte); + + public static final PrimitiveType SHORT_TYPE = new PrimitiveType(Primitive.Short); + + public static final PrimitiveType INT_TYPE = new PrimitiveType(Primitive.Int); + + public static final PrimitiveType LONG_TYPE = new PrimitiveType(Primitive.Long); + + public static final PrimitiveType FLOAT_TYPE = new PrimitiveType(Primitive.Float); + + public static final PrimitiveType DOUBLE_TYPE = new PrimitiveType(Primitive.Double); + + public static final PrimitiveType BOOLEAN_TYPE = new PrimitiveType(Primitive.Boolean); + + public static final PrimitiveType CHAR_TYPE = new PrimitiveType(Primitive.Char); + + public static final VoidType VOID_TYPE = new VoidType(); + + private ASTHelper() { + // nop + } + + /** + * Creates a new {@link NameExpr} from a qualified name.<br> + * The qualified name can contains "." (dot) characters. + * + * @param qualifiedName + * qualified name + * @return instanceof {@link NameExpr} + */ + public static NameExpr createNameExpr(String qualifiedName) { + String[] split = qualifiedName.split("\\."); + NameExpr ret = new NameExpr(split[0]); + for (int i = 1; i < split.length; i++) { + ret = new QualifiedNameExpr(ret, split[i]); + } + return ret; + } + + /** + * Creates a new {@link Parameter}. + * + * @param type + * type of the parameter + * @param name + * name of the parameter + * @return instance of {@link Parameter} + */ + public static Parameter createParameter(Type type, String name) { + return new Parameter(type, new VariableDeclaratorId(name)); + } + + /** + * Creates a {@link FieldDeclaration}. + * + * @param modifiers + * modifiers + * @param type + * type + * @param variable + * variable declarator + * @return instance of {@link FieldDeclaration} + */ + public static FieldDeclaration createFieldDeclaration(int modifiers, Type type, VariableDeclarator variable) { + List<VariableDeclarator> variables = new ArrayList<VariableDeclarator>(); + variables.add(variable); + FieldDeclaration ret = new FieldDeclaration(modifiers, type, variables); + return ret; + } + + /** + * Creates a {@link FieldDeclaration}. + * + * @param modifiers + * modifiers + * @param type + * type + * @param name + * field name + * @return instance of {@link FieldDeclaration} + */ + public static FieldDeclaration createFieldDeclaration(int modifiers, Type type, String name) { + VariableDeclaratorId id = new VariableDeclaratorId(name); + VariableDeclarator variable = new VariableDeclarator(id); + return createFieldDeclaration(modifiers, type, variable); + } + + /** + * Creates a {@link VariableDeclarationExpr}. + * + * @param type + * type + * @param name + * name + * @return instance of {@link VariableDeclarationExpr} + */ + public static VariableDeclarationExpr createVariableDeclarationExpr(Type type, String name) { + List<VariableDeclarator> vars = new ArrayList<VariableDeclarator>(); + vars.add(new VariableDeclarator(new VariableDeclaratorId(name))); + return new VariableDeclarationExpr(type, vars); + } + + /** + * Adds the given parameter to the method. The list of parameters will be + * initialized if it is <code>null</code>. + * + * @param method + * method + * @param parameter + * parameter + */ + public static void addParameter(MethodDeclaration method, Parameter parameter) { + List<Parameter> parameters = method.getParameters(); + if (parameters == null) { + parameters = new ArrayList<Parameter>(); + method.setParameters(parameters); + } + parameters.add(parameter); + } + + /** + * Adds the given argument to the method call. The list of arguments will be + * initialized if it is <code>null</code>. + * + * @param call + * method call + * @param arg + * argument value + */ + public static void addArgument(MethodCallExpr call, Expression arg) { + List<Expression> args = call.getArgs(); + if (args == null) { + args = new ArrayList<Expression>(); + call.setArgs(args); + } + args.add(arg); + } + + /** + * Adds the given type declaration to the compilation unit. The list of + * types will be initialized if it is <code>null</code>. + * + * @param cu + * compilation unit + * @param type + * type declaration + */ + public static void addTypeDeclaration(CompilationUnit cu, TypeDeclaration type) { + List<TypeDeclaration> types = cu.getTypes(); + if (types == null) { + types = new ArrayList<TypeDeclaration>(); + cu.setTypes(types); + } + types.add(type); + + } + + /** + * Creates a new {@link ReferenceType} for a class or interface. + * + * @param name + * name of the class or interface + * @param arrayCount + * number of arrays or <code>0</code> if is not a array. + * @return instanceof {@link ReferenceType} + */ + public static ReferenceType createReferenceType(String name, int arrayCount) { + return new ReferenceType(new ClassOrInterfaceType(name), arrayCount); + } + + /** + * Creates a new {@link ReferenceType} for the given primitive type. + * + * @param type + * primitive type + * @param arrayCount + * number of arrays or <code>0</code> if is not a array. + * @return instanceof {@link ReferenceType} + */ + public static ReferenceType createReferenceType(PrimitiveType type, int arrayCount) { + return new ReferenceType(type, arrayCount); + } + + /** + * Adds the given statement to the specified block. The list of statements + * will be initialized if it is <code>null</code>. + * + * @param block to have expression added to + * @param stmt to be added + */ + public static void addStmt(BlockStmt block, Statement stmt) { + List<Statement> stmts = block.getStmts(); + if (stmts == null) { + stmts = new ArrayList<Statement>(); + block.setStmts(stmts); + } + stmts.add(stmt); + } + + /** + * Adds the given expression to the specified block. The list of statements + * will be initialized if it is <code>null</code>. + * + * @param block to have expression added to + * @param expr to be added + */ + public static void addStmt(BlockStmt block, Expression expr) { + addStmt(block, new ExpressionStmt(expr)); + } + + /** + * Adds the given declaration to the specified type. The list of members + * will be initialized if it is <code>null</code>. + * + * @param type + * type declaration + * @param decl + * member declaration + */ + public static void addMember(TypeDeclaration type, BodyDeclaration decl) { + List<BodyDeclaration> members = type.getMembers(); + if (members == null) { + members = new ArrayList<BodyDeclaration>(); + type.setMembers(members); + } + members.add(decl); + } + + public static <N extends Node> List<N> getNodesByType(Node container, Class<N> clazz) { + List<N> nodes = new ArrayList<N>(); + for (Node child : container.getChildrenNodes()) { + if (clazz.isInstance(child)) { + nodes.add(clazz.cast(child)); + } + nodes.addAll(getNodesByType(child, clazz)); + } + return nodes; + } + +} |