@Override public <T> void visitCtLiteral(CtLiteral<T> literal) { enterCtExpression(literal); printer.writeLiteral(LiteralHelper.getLiteralToken(literal)); exitCtExpression(literal); }
@Override public <T> void visitCtVariableRead(CtVariableRead<T> variableRead) { enterCtExpression(variableRead); printer.writeIdentifier(variableRead.getVariable().getSimpleName()); exitCtExpression(variableRead); }
@Override public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) { enterCtStatement(ctConstructorCall); enterCtExpression(ctConstructorCall); printConstructorCall(ctConstructorCall); exitCtExpression(ctConstructorCall); exitCtStatement(ctConstructorCall); }
@Override public <T> void visitCtVariableWrite(CtVariableWrite<T> variableWrite) { enterCtExpression(variableWrite); printer.writeIdentifier(variableWrite.getVariable().getSimpleName()); exitCtExpression(variableWrite); }
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { if (typeAccess.isImplicit()) { return; } enterCtExpression(typeAccess); scan(typeAccess.getAccessedType()); exitCtExpression(typeAccess); }
@Override public <T> void visitCtSuperAccess(CtSuperAccess<T> f) { enterCtExpression(f); if (f.getTarget() != null) { scan(f.getTarget()); printer.writeSeparator("."); } printer.writeKeyword("super"); exitCtExpression(f); }
@Override public <T> void visitCtNewClass(CtNewClass<T> newClass) { enterCtStatement(newClass); enterCtExpression(newClass); printConstructorCall(newClass); scan(newClass.getAnonymousClass()); exitCtExpression(newClass); exitCtStatement(newClass); }
private <T, E extends CtExpression<?>> void printCtArrayAccess(CtArrayAccess<T, E> arrayAccess) { enterCtExpression(arrayAccess); scan(arrayAccess.getTarget()); printer.writeSeparator("["); scan(arrayAccess.getIndexExpression()); printer.writeSeparator("]"); exitCtExpression(arrayAccess); }
@Override public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> assignement) { enterCtStatement(assignement); enterCtExpression(assignement); scan(assignement.getAssigned()); printer.writeSpace().writeOperator("=").writeSpace(); scan(assignement.getAssignment()); exitCtExpression(assignement); exitCtStatement(assignement); }
@Override public <T, A extends T> void visitCtOperatorAssignment(CtOperatorAssignment<T, A> assignment) { enterCtStatement(assignment); enterCtExpression(assignment); scan(assignment.getAssigned()); printer.writeSpace(); // the operators like +=, *= are sent as one operator token printer.writeOperator(OperatorHelper.getOperatorText(assignment.getKind()) + "="); printer.writeSpace(); scan(assignment.getAssignment()); exitCtExpression(assignment); exitCtStatement(assignment); }
@Override public <T> void visitCtLambda(CtLambda<T> lambda) { enterCtExpression(lambda); elementPrinterHelper.printList(lambda.getParameters(), null, false, "(", false, false, ",", false, false, ")", parameter -> scan(parameter)); printer.writeSpace(); printer.writeSeparator("->"); printer.writeSpace(); if (lambda.getBody() != null) { scan(lambda.getBody()); } else { scan(lambda.getExpression()); } exitCtExpression(lambda); }
exitCtExpression(thisAccess);
@Override public <T> void visitCtAnnotationFieldAccess(CtAnnotationFieldAccess<T> annotationFieldAccess) { enterCtExpression(annotationFieldAccess); try (Writable _context = context.modify()) { if (annotationFieldAccess.getTarget() != null) { scan(annotationFieldAccess.getTarget()); printer.writeSeparator("."); _context.ignoreStaticAccess(true); } _context.ignoreGenerics(true); scan(annotationFieldAccess.getVariable()); printer.writeSeparator("(").writeSeparator(")"); } exitCtExpression(annotationFieldAccess); }
@Override public <T> void visitCtUnaryOperator(CtUnaryOperator<T> operator) { enterCtStatement(operator); enterCtExpression(operator); UnaryOperatorKind op = operator.getKind(); if (OperatorHelper.isPrefixOperator(op)) { printer.writeOperator(OperatorHelper.getOperatorText(op)); } scan(operator.getOperand()); if (OperatorHelper.isSufixOperator(op)) { printer.writeOperator(OperatorHelper.getOperatorText(op)); } exitCtExpression(operator); exitCtStatement(operator); }
exitCtExpression(newArray);
@Override public <T> void visitCtBinaryOperator(CtBinaryOperator<T> operator) { enterCtExpression(operator); scan(operator.getLeftHandOperand()); printer.writeSpace(); printer.writeOperator(OperatorHelper.getOperatorText(operator.getKind())); printer.writeSpace(); try (Writable _context = context.modify()) { if (operator.getKind() == BinaryOperatorKind.INSTANCEOF) { _context.forceWildcardGenerics(true); } scan(operator.getRightHandOperand()); } exitCtExpression(operator); }
@Override public <T, E extends CtExpression<?>> void visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T, E> expression) { enterCtExpression(expression); try (Writable _context = context.modify()) { if (expression.getExecutable().isStatic()) { _context.ignoreGenerics(true); } scan(expression.getTarget()); } printer.writeSeparator("::"); if (expression.getExecutable().isConstructor()) { printer.writeKeyword("new"); } else { printer.writeIdentifier(expression.getExecutable().getSimpleName()); } exitCtExpression(expression); }
printer.writeSeparator(")"); exitCtExpression(conditional);
null, false, "(", false, false, ",", true, false, ")", e -> scan(e)); exitCtExpression(invocation); exitCtStatement(invocation);