Refine search
@Override public void visit(BlockStmt n, Void arg) { out.println("BlockStmt: " + (extended ? n : n.getStatements().size() + " statements")); super.visit(n, arg); }
/** * Given a method declaration node this method will replace it's code and * signature with code to redirect all calls to it to the * <code>newMethodName</code>. Method signatures of both methods must match * exactly. * * @param methodToPatch * @param toMethodName * @param returnType * @param parameters */ private static void patchMethodAsDepreciatedRedirector(MethodDeclaration methodToPatch, String toMethodName, Type returnType, Parameter... parameters) { methodToPatch.setType(returnType); for (Parameter parameter : parameters) { methodToPatch.addParameter(parameter); } methodToPatch.addAnnotation(new MarkerAnnotationExpr("Deprecated")); methodToPatch.setJavadocComment( formatMultilineJavadoc(1, "@deprecated This was renamed to " + toMethodName + " please migrate")); MethodCallExpr methodCall = methodCallExpr("this", toMethodName); for (Parameter parameter : parameters) { methodCall.addArgument(new NameExpr(parameter.getName())); } BlockStmt body = new BlockStmt(); body.addStatement(new ReturnStmt(methodCall)); methodToPatch.setBody(body); }
/** * Generates something like <code>return field</code> * * @param fieldName * @return */ private static BlockStmt returnField(String fieldName) { BlockStmt body = new BlockStmt(); body.addStatement(new ReturnStmt(fieldName)); return body; }
@Test public void accessEnumMethodThroughThis() throws ParseException { CompilationUnit cu = parseSample("AccessEnumMemberThroughThis"); com.github.javaparser.ast.body.EnumDeclaration enumDecl = Navigator.demandEnum(cu, "AccessEnumMemberThroughThis"); MethodDeclaration method = Navigator.demandMethod(enumDecl, "getLabel2"); ReturnStmt returnStmt = (ReturnStmt) method.getBody().get().getStatements().get(0); Expression expression = returnStmt.getExpression().get(); ResolvedType ref = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression); assertEquals("java.lang.String", ref.describe()); }
if (callExpr.getScope().isPresent()) { Expression scope = callExpr.getScope().get(); if (functionalMethod.isPresent()) { LambdaExpr lambdaExpr = node; } else if (lambdaExpr.getBody() instanceof BlockStmt) { BlockStmt blockStmt = (BlockStmt) lambdaExpr.getBody(); NodeList<Statement> statements = blockStmt.getStatements(); List<ReturnStmt> returnStmts = blockStmt.getNodesByType(ReturnStmt.class);
@Test public void issue257() throws FileNotFoundException { String pathToSourceFile = adaptPath("src/test/resources/issue257/A.java.txt"); CompilationUnit cu = JavaParser.parse(new File(pathToSourceFile)); Statement statement = cu.getClassByName("A").get().getMethodsByName("run").get(0).getBody().get().getStatement(0); ExpressionStmt expressionStmt = (ExpressionStmt)statement; Expression expression = expressionStmt.getExpression(); JavaParserFacade.get(typeSolver).getType(expression); }
/** * This method checks if a parameter with a specific name is used inside a * method. * * @param method * @param paramName * @return used/notUsed */ private boolean checkIfParameterUsed(MethodDeclaration method, String paramName) { // Check if Method has body if (method.getBody().isPresent()) { // Get body BlockStmt methodBody = method.getBody().get(); // Get all expressions from body List<NameExpr> expressions = methodBody.findAll(NameExpr.class); // Iterate expressions for (NameExpr expression : expressions) { // If expression name = param name if (expression.getNameAsString().equals(paramName)) { // Parameter used return true; } } } // Parameter not used return false; }
((p1 = n.getParentNode()).isPresent() && p1.get() instanceof ExpressionStmt) && ((p2 = p1.get().getParentNode()).isPresent() && p2.get() instanceof BlockStmt) && ((p3 = p2.get().getParentNode()).isPresent() && p3.get() == get_set_method)) { NodeList<Statement> stmts = ((BlockStmt)p2.get()).getStatements(); stmts.set(stmts.indexOf(p1.get()), new EmptyStmt()); return;
addElement.addParameter("String", "newElement"); addElement.getBody().get().getStatements().add(new ExpressionStmt( new MethodCallExpr(new NameExpr("elements"), new SimpleName("add"), NodeList.nodeList(new NameExpr("newElement"))) getElements.setType("Collection<String>"); getElements.getBody().get().getStatements().add(new ReturnStmt( new NameExpr("elements")));
String name = n.getNameAsString(); isGetter = isArraySetter = false; do { // to provide break exit Character.isUpperCase(name.charAt(3)) && !name.equals("getTypeIndexID")) { List<Parameter> ps = n.getParameters(); if (isGetter) { if (ps.size() > 1) break; String bodyString = n.getBody().get().toString(printWithoutComments); int i = bodyString.indexOf("jcasType.ll_cas.ll_"); if (i < 0) break; for (Statement stmt : n.getBody().get().getStatements()) { if (stmt instanceof ReturnStmt) { Expression e = getUnenclosedExpr(((ReturnStmt)stmt).getExpression().get()); if ((e instanceof MethodCallExpr)) { String methodName = ((MethodCallExpr)e).getNameAsString();
@Test public void arrayTypeIsNotPartOfTheTree() throws ParseException { CompilationUnit cu = parseSample("Issue116"); ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "JavaTest"); MethodDeclaration methodDeclaration = Navigator.demandMethod(clazz, "foo"); TypeSolver typeSolver = new ReflectionTypeSolver(); JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver); com.github.javaparser.ast.type.Type typeNode = methodDeclaration.getParameters().get(0).getType(); ResolvedType type = javaParserFacade.convert(typeNode, typeNode); assertEquals("java.lang.String[]", type.describe()); ExpressionStmt expressionStmt = (ExpressionStmt) methodDeclaration.getBody().get().getStatements().get(0); Expression argRef = expressionStmt.getExpression(); assertEquals("java.lang.String[]", javaParserFacade.getType(argRef).describe()); } }
BlockStmt parent = (BlockStmt) n.getParentNode().get(); stmts = parent.getStatements(); stmts.set(stmts.indexOf(n), new EmptyStmt()); //dont remove
@Override public Boolean visit(BlockStmt n, Void arg) { // An empty block that is not a switch block can complete normally iff it is reachable if (n.isEmpty() && !parentIs(statement, SwitchStmt.class)) { return isReachable(statement); } // A non-empty block that is not a switch block can complete normally iff the last statement in // it can complete normally. if (!n.isEmpty() && !parentIs(statement, SwitchStmt.class)) { return canCompleteNormally(n.getStatement(n.getStatements().size() - 1)); } throw new UnsupportedOperationException(); }
@Override public Map<String, ResultType> parseStatements( List<String> statements, Collection<String> importedClasses, @Nullable ClassLoaderContext classLoaderContext ) throws ParseException { StringBuilder codeBuilder = new StringBuilder( "class X {" ); codeBuilder.append( "void run() {" ); for (String statement : statements) { codeBuilder.append( statement ); } codeBuilder.append( "} }" ); List<Statement> parsedStatements; try { CompilationUnit compilationUnit = JavaParser.parse( new StringReader( codeBuilder.toString() ), false ); MethodDeclaration methodDeclaration = ( MethodDeclaration ) compilationUnit .getTypes().get( 0 ) .getMembers().get( 0 ); parsedStatements = methodDeclaration.getBody().getStmts(); } catch ( com.github.javaparser.ParseException e ) { throw new ParseException( e.getMessage(), 0 ); } return resultTypes( new TypeDiscoverer( importedClasses, classLoaderContext ) .getTypesByVariableName( parsedStatements ) ); }
private MethodDeclaration getterDeclaration(EntityField field) { MethodDeclaration decl = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.createReferenceType(field.getType().getSimpleName(), 0), "get" + CaseConverter.pascalCase(field.getName())); BlockStmt body = new BlockStmt(); body.setStmts( Collections.singletonList( new ReturnStmt( new FieldAccessExpr(new ThisExpr(), field.getName())))); decl.setBody(body); return decl; }
implementList.add(new ClassOrInterfaceType("JdbcMigration")); migrationClass.setImplements(implementList); MethodDeclaration migrateMethod = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.VOID_TYPE, "migrate"); ASTHelper.addMember(migrationClass, migrateMethod); ASTHelper.addParameter(migrateMethod, ASTHelper.createParameter( ASTHelper.createReferenceType("Connection", 0), "connection" )); migrateMethod.setThrows(Collections.singletonList(ASTHelper.createNameExpr("Exception"))); migrateMethod.setAnnotations(annotations); BlockStmt block = new BlockStmt(); migrateMethod.setBody(block);
public static BlockStmt mergeBlock(BlockStmt one, BlockStmt two) { if (isAllNull(one, two)) return null; BlockStmt blockStmt = null; if (isAllNotNull(one, two)) { blockStmt = new BlockStmt(); blockStmt.setComment(mergeSelective(one.getComment(), two.getComment())); blockStmt.setStmts(mergeListInOrder(one.getStmts(), two.getStmts())); } else { blockStmt = findFirstNotNull(one, two); } return blockStmt; }