private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
@Override public boolean doIsEquals(VariableDeclaratorId first, VariableDeclaratorId second) { if(!StringUtils.equals(first.getName(),second.getName())) return false; if(first.getArrayCount() != second.getArrayCount()) return false; return true; } }
private FieldDeclaration fieldDeclaration(EntityField field) { VariableDeclarator variableDec = new VariableDeclarator(new VariableDeclaratorId(field.getName())); List<AnnotationExpr> annoList = new ArrayList<>(); return new FieldDeclaration(ModifierSet.PRIVATE, annoList, ASTHelper.createReferenceType(field.getType().getSimpleName(), 0), Collections.singletonList(variableDec)); }
public List<RouteParam> accept(final Node node, final Context ctx) { if (node instanceof LambdaExpr) { ((LambdaExpr) node).getParameters().forEach(p -> { names.add(p.getId().toStringWithoutComments()); }); } node.accept(this, ctx); return params; }
public static <T extends BaseParameter> boolean isParametersEquals(List<T> one, List<T> two) { boolean isEqual = true; if (isAllNull(one, two)) { isEqual = true; } else if (isAllNotNull(one, two)) { if (one.size() != two.size()) { isEqual = false; } else { for (int index = 0; index < one.size(); index++) { T t1 = one.get(index); T t2 = one.get(index); if (!t1.getId().equals(t2.getId())) { isEqual = false; break; } } } } else { isEqual = false; } return isEqual; }
private VariableDeclarationExpr createAssignStatement() { VariableDeclarationExpr expr = ASTHelper.createVariableDeclarationExpr(ASTHelper.createReferenceType("Statement", 0), "stmt"); expr.setVars(Collections.singletonList(new VariableDeclarator( new VariableDeclaratorId("stmt"), new MethodCallExpr(ASTHelper.createNameExpr("connection"), "createStatement") ))); return expr; } private BlockStmt createStatementExecuteBlock() {
@Override public void visit(final VariableDeclarator n, final Context ctx) { String id = n.getId().toStringWithoutComments(); values.put(id, n.getInit().accept(new LiteralCollector(), ctx)); }
private JavaMethod createMethod (MethodDeclaration method) { String className = classStack.peek().getName(); String name = method.getName(); boolean isStatic = ModifierSet.hasModifier(method.getModifiers(), ModifierSet.STATIC); String returnType = method.getType().toString(); ArrayList<Argument> arguments = new ArrayList<Argument>(); if (method.getParameters() != null) { for (Parameter parameter : method.getParameters()) { arguments.add(new Argument(getArgumentType(parameter), parameter.getId().getName())); } } return new JavaMethod(className, name, isStatic, returnType, null, arguments, method.getBeginLine(), method.getEndLine()); }
private void refactor(MethodDeclaration methodDeclaration, StringLiteralExpr memberValue, SingleMemberAnnotationExpr annotation) { if (StringEscapeUtils.unescapeJava(memberValue.getValue()).trim().equals(oldStepValue.getStepAnnotationText().trim())) { newParameters = Arrays.asList(new Parameter[paramPositions.size()]); memberValue.setValue(StringEscapeUtils.escapeJava(newStepValue.getStepAnnotationText())); List<Parameter> parameters = methodDeclaration.getParameters(); for (int i = 0, paramPositionsSize = paramPositions.size(); i < paramPositionsSize; i++) { if (paramPositions.get(i).getOldPosition() < 0) { String paramName = Util.getValidJavaIdentifier(Util.convertToCamelCase("arg " + newStepValue.getParameters().get(i))); if (paramName.equals("arg")) { paramName += i; } newParameters.set(paramPositions.get(i).getNewPosition(), new Parameter(new ClassOrInterfaceType("Object"), new VariableDeclaratorId(paramName))); } else { newParameters.set(paramPositions.get(i).getNewPosition(), parameters.get(paramPositions.get(i).getOldPosition())); } } for (int k = 0; k < newParameters.size(); k++) { for (int l = k + 1; l < newParameters.size(); l++) { if (newParameters.get(k).getName().equals(newParameters.get(l).getName())) { newParameters.set(l, new Parameter(new ClassOrInterfaceType("Object"), new VariableDeclaratorId(newParameters.get(l).getName() + l))); } } } methodDeclaration.setParameters(newParameters); annotation.setMemberValue(memberValue); this.javaElement = new JavaRefactoringElement(getJavaFileText(methodDeclaration), null); stepSpan = annotation.getChildrenNodes().get(1).getRange(); this.refactored = true; } }
public RouteResponse accept(final Node node, final Context ctx, final Type retType, final String doc, final Map<Integer, String> codes) { this.type = retType; boolean lambda = node instanceof LambdaExpr; if (lambda) { ((LambdaExpr) node).getParameters() .forEach(p -> args.add(p.getId().toStringWithoutComments())); } if (this.type == null) { node.accept(this, ctx); if (type == null && lambda) { LambdaExpr expr = (LambdaExpr) node; if (expr.getChildrenNodes().size() == 1) { type = expr.getChildrenNodes().get(0).accept(new TypeCollector(), ctx); } } } return new RouteResponseImpl(this.type == null ? Object.class : this.type, doc, codes); }
@Override public void visit(final VariableDeclarator n, final Context ctx) { vars.put(n.getId().getName(), n.getInit()); }
private void refactor(MethodDeclaration methodDeclaration, StringLiteralExpr memberValue, SingleMemberAnnotationExpr annotation) { if (StringEscapeUtils.unescapeJava(memberValue.getValue()).trim().equals(oldStepValue.getStepAnnotationText().trim())) { newParameters = Arrays.asList(new Parameter[paramPositions.size()]); memberValue.setValue(StringEscapeUtils.escapeJava(newStepValue.getStepAnnotationText())); List<Parameter> parameters = methodDeclaration.getParameters(); for (int i = 0, paramPositionsSize = paramPositions.size(); i < paramPositionsSize; i++) { if (paramPositions.get(i).getOldPosition() < 0) { String paramName = Util.getValidJavaIdentifier(Util.convertToCamelCase("arg " + newStepValue.getParameters().get(i))); if (paramName.equals("arg")) { paramName += i; } newParameters.set(paramPositions.get(i).getNewPosition(), new Parameter(new ClassOrInterfaceType("Object"), new VariableDeclaratorId(paramName))); } else { newParameters.set(paramPositions.get(i).getNewPosition(), parameters.get(paramPositions.get(i).getOldPosition())); } } for (int k = 0; k < newParameters.size(); k++) { for (int l = k + 1; l < newParameters.size(); l++) { if (newParameters.get(k).getName().equals(newParameters.get(l).getName())) { newParameters.set(l, new Parameter(new ClassOrInterfaceType("Object"), new VariableDeclaratorId(newParameters.get(l).getName() + l))); } } } methodDeclaration.setParameters(newParameters); annotation.setMemberValue(memberValue); this.javaElement = new JavaRefactoringElement(getJavaFileText(methodDeclaration), null); stepSpan = annotation.getChildrenNodes().get(1).getRange(); this.refactored = true; } }
private void addFieldVariables(@Nullable Iterable<? extends BodyDeclaration> declarations, @Nonnull Set<String> variables) { for (FieldDeclaration fieldDeclaration : emptyIfNull(declarations). filter(FieldDeclaration.class).filter(not(constants()))) { for (VariableDeclarator variableDeclarator : fieldDeclaration.getVariables()) { variables.add(variableDeclarator.getId().getName()); } } }
private MethodDeclaration setterDeclaration(EntityField field) { MethodDeclaration decl = new MethodDeclaration(ModifierSet.PUBLIC, new VoidType(), "set" + CaseConverter.pascalCase(field.getName()), Collections.singletonList(new Parameter( ASTHelper.createReferenceType(field.getType().getSimpleName(), 0), new VariableDeclaratorId(field.getName())))); BlockStmt body = new BlockStmt(); body.setStmts( Collections.singletonList( new ExpressionStmt( new AssignExpr( new FieldAccessExpr(new ThisExpr(), field.getName()), ASTHelper.createNameExpr(field.getName()), AssignExpr.Operator.assign )))); decl.setBody(body); return decl; }
@Override public void visit(LambdaExpr n, A arg) { HashSet<String> blockVariables = newHashSet(); this.localVariables.addLast(blockVariables); try { for (Parameter parameter : emptyIfNull(n.getParameters())) { blockVariables.add(parameter.getId().getName()); } super.visit(n, arg); } finally { this.localVariables.removeLast(); } }
@Override public void visit(TryStmt n, A arg) { HashSet<String> blockVariables = newHashSet(); this.localVariables.addLast(blockVariables); try { for (VariableDeclarationExpr variableDeclarationExpr : emptyIfNull(n.getResources())) { for (VariableDeclarator variableDeclarator : variableDeclarationExpr.getVars()) { blockVariables.add(variableDeclarator.getId().getName()); } } super.visit(n, arg); } finally { this.localVariables.removeLast(); } }
Map<String, Class<?>> getTypesByVariableName( List<Statement> statements ) { Map<String, Class<?>> typeByVariableName = new HashMap<>(); for (Statement statement : statements) { if ( statement instanceof ExpressionStmt ) { Expression expression = ( ( ExpressionStmt ) statement ).getExpression(); if ( expression instanceof VariableDeclarationExpr ) { VariableDeclarationExpr varExpression = ( VariableDeclarationExpr ) expression; @Nullable Class<?> type = typeOf( varExpression.getType() ); if ( type != null ) { for (VariableDeclarator var : varExpression.getVars()) { typeByVariableName.put( var.getId().getName(), type ); } } } } } return typeByVariableName; }
@Override public void visit(ForeachStmt n, A arg) { HashSet<String> blockVariables = newHashSet(); this.localVariables.addLast(blockVariables); try { for (VariableDeclarator variableDeclarator : emptyIfNull(n.getVariable().getVars())) { blockVariables.add(variableDeclarator.getId().getName()); } n.getIterable().accept(this, arg); n.getBody().accept(this, arg); } finally { this.localVariables.removeLast(); } }
@Override public void visit(final VariableDeclarationExpr n, final Context ctx) { if (visited.add(n)) { try { Type type = n.getType().accept(new TypeCollector(), ctx); n.getVars().forEach(v -> { VariableDeclaratorId id = v.getId(); vars.put(id.getName(), type); }); } catch (IllegalArgumentException ex) { log.warn("Type not found {}", n, ex); } } super.visit(n, ctx); }
@Override public void visit(FieldDeclaration fd, List<EntityField> f) { if (fd.getAnnotations().stream().anyMatch(anno -> anno.getName().getName().equals("Column"))) { Class<?> type = null; switch (fd.getType().toString()) { case "String": type = String.class; break; case "Long": type = Long.class; break; case "Integer": type = Integer.class; break; case "boolean": type = boolean.class; break; } if (type == null) return; f.add(new EntityField( fd.getVariables().get(0).getId().getName(), type, fd.getAnnotations().stream().anyMatch(anno -> anno.getName().getName().equals("Id")))); } } }, entityFields);