/** * Write the compilation unit footer. */ public void writeFooter(List<CtType<?>> types) { if (!types.isEmpty()) { for (CtType<?> ctType : types) { writeComment(ctType, CommentOffset.BOTTOM_FILE); } } }
public void writeComment(CtElement element) { if (element == null) { return; } writeComment(element.getComments()); }
/** * Exits an expression. */ protected void exitCtExpression(CtExpression<?> e) { while ((!context.parenthesedExpression.isEmpty()) && e == context.parenthesedExpression.peek()) { context.parenthesedExpression.pop(); printer.writeSeparator(")"); } if (!(e instanceof CtStatement)) { elementPrinterHelper.writeComment(e, CommentOffset.AFTER); } }
private void writeComment(List<CtComment> comments) { if (!env.isCommentsEnabled() || comments == null) { return; } for (CtComment comment : comments) { writeComment(comment); } }
public void writeComment(CtElement element, CommentOffset offset) { writeComment(getComments(element, offset)); }
@Override public <T> void visitCtCodeSnippetExpression(CtCodeSnippetExpression<T> expression) { elementPrinterHelper.writeComment(expression); printer.writeCodeSnippet(expression.getValue()); }
/** * Exits a statement. */ protected void exitCtStatement(CtStatement statement) { if (!(statement instanceof CtBlock || statement instanceof CtIf || statement instanceof CtFor || statement instanceof CtForEach || statement instanceof CtWhile || statement instanceof CtTry || statement instanceof CtSwitch || statement instanceof CtSynchronized || statement instanceof CtClass || statement instanceof CtComment)) { if (context.isStatement(statement) && !context.isFirstForVariable() && !context.isNextForVariable()) { printer.writeSeparator(";"); } } elementPrinterHelper.writeComment(statement, CommentOffset.AFTER); }
@Override public void visitCtAnonymousExecutable(CtAnonymousExecutable impl) { elementPrinterHelper.writeComment(impl); elementPrinterHelper.writeAnnotations(impl); elementPrinterHelper.writeModifiers(impl); scan(impl.getBody()); }
/** * Write the compilation unit header. */ public void writeHeader(List<CtType<?>> types, Collection<CtImport> imports) { if (!types.isEmpty()) { for (CtType<?> ctType : types) { writeComment(ctType, CommentOffset.TOP_FILE); } // writing the header package if (!types.get(0).getPackage().isUnnamedPackage()) { writePackageLine(types.get(0).getPackage().getQualifiedName()); } this.writeImports(imports); printer.writeln(); printer.writeln(); } }
private <T> void visitCtType(CtType<T> type) { elementPrinterHelper.writeComment(type, CommentOffset.BEFORE); getPrinterHelper().mapLine(type, sourceCompilationUnit); if (type.isTopLevel()) { context.currentTopLevel = type; } elementPrinterHelper.visitCtNamedElement(type, sourceCompilationUnit); elementPrinterHelper.writeModifiers(type); }
/** * Enters an expression. */ protected void enterCtExpression(CtExpression<?> e) { if (!(e instanceof CtStatement)) { elementPrinterHelper.writeComment(e, CommentOffset.BEFORE); } getPrinterHelper().mapLine(e, sourceCompilationUnit); if (shouldSetBracket(e)) { context.parenthesedExpression.push(e); printer.writeSeparator("("); } if (!e.getTypeCasts().isEmpty()) { for (CtTypeReference<?> r : e.getTypeCasts()) { printer.writeSeparator("("); scan(r); printer.writeSeparator(")").writeSpace(); printer.writeSeparator("("); context.parenthesedExpression.push(e); } } }
@Override public <T> void visitCtField(CtField<T> f) { elementPrinterHelper.writeComment(f, CommentOffset.BEFORE); elementPrinterHelper.visitCtNamedElement(f, sourceCompilationUnit); elementPrinterHelper.writeModifiers(f); scan(f.getType()); printer.writeSpace(); printer.writeIdentifier(f.getSimpleName()); if (f.getDefaultExpression() != null) { printer.writeSpace().writeOperator("=").writeSpace(); scan(f.getDefaultExpression()); } printer.writeSeparator(";"); elementPrinterHelper.writeComment(f, CommentOffset.AFTER); }
@Override public <T> void visitCtParameter(CtParameter<T> parameter) { elementPrinterHelper.writeComment(parameter); elementPrinterHelper.writeAnnotations(parameter); elementPrinterHelper.writeModifiers(parameter); if (parameter.isVarArgs()) { scan(((CtArrayTypeReference<T>) parameter.getType()).getComponentType()); printer.writeSeparator("..."); } else { scan(parameter.getType()); } printer.writeSpace(); printer.writeIdentifier(parameter.getSimpleName()); }
@Override public <T> void visitCtEnumValue(CtEnumValue<T> enumValue) { elementPrinterHelper.visitCtNamedElement(enumValue, sourceCompilationUnit); elementPrinterHelper.writeComment(enumValue, CommentOffset.BEFORE); printer.writeIdentifier(enumValue.getSimpleName()); if (enumValue.getDefaultExpression() != null) { CtConstructorCall<?> constructorCall = (CtConstructorCall<?>) enumValue.getDefaultExpression(); if (!constructorCall.isImplicit()) { elementPrinterHelper.printList(constructorCall.getArguments(), null, false, "(", false, false, ",", true, false, ")", expr -> scan(expr)); } if (constructorCall instanceof CtNewClass) { scan(((CtNewClass<?>) constructorCall).getAnonymousClass()); } } }
@Override public String printPackageInfo(CtPackage pack) { reset(); elementPrinterHelper.writeComment(pack); // we need to compute imports only for annotations // we don't want to get all imports coming from content of package for (CtAnnotation annotation : pack.getAnnotations()) { this.importsContext.computeImports(annotation); } elementPrinterHelper.writeAnnotations(pack); if (!pack.isUnnamedPackage()) { elementPrinterHelper.writePackageLine(pack.getQualifiedName()); } elementPrinterHelper.writeImports(this.importsContext.getAllImports()); return printer.getPrinterHelper().toString(); }
@Override public <T> void visitCtConstructor(CtConstructor<T> constructor) { elementPrinterHelper.writeComment(constructor); elementPrinterHelper.visitCtNamedElement(constructor, sourceCompilationUnit); elementPrinterHelper.writeModifiers(constructor); elementPrinterHelper.writeFormalTypeParameters(constructor); if (!constructor.getFormalCtTypeParameters().isEmpty()) { printer.writeSpace(); } if (constructor.getDeclaringType() != null) { if (constructor.getDeclaringType().isLocalType()) { printer.writeIdentifier(constructor.getDeclaringType().getSimpleName().replaceAll("^[0-9]*", "")); } else { printer.writeIdentifier(constructor.getDeclaringType().getSimpleName()); } } elementPrinterHelper.writeExecutableParameters(constructor); elementPrinterHelper.writeThrowsClause(constructor); printer.writeSpace(); scan(constructor.getBody()); }
/** * Enters a statement. */ protected void enterCtStatement(CtStatement s) { elementPrinterHelper.writeComment(s, CommentOffset.BEFORE); getPrinterHelper().mapLine(s, sourceCompilationUnit); if (!context.isNextForVariable()) { //TODO AnnotationLoopTest#testAnnotationDeclaredInForInit expects that annotations of next for variables are not printed //but may be correct is that the next variables are not annotated, because they might have different annotation then first param! elementPrinterHelper.writeAnnotations(s); } if (!context.isFirstForVariable() && !context.isNextForVariable()) { if (s.getLabel() != null) { printer.writeIdentifier(s.getLabel()).writeSpace().writeSeparator(":").writeSpace(); } } }
@Override public void visitCtCatch(CtCatch catchBlock) { elementPrinterHelper.writeComment(catchBlock, CommentOffset.BEFORE); printer.writeSpace().writeKeyword("catch").writeSpace().writeSeparator("("); CtCatchVariable<? extends Throwable> parameter = catchBlock.getParameter(); if (parameter != null && parameter.getMultiTypes().size() > 1) { elementPrinterHelper.printList(parameter.getMultiTypes(), null, false, null, false, true, "|", true, false, null, type -> scan(type)); printer.writeSpace().writeIdentifier(parameter.getSimpleName()); } else { scan(parameter); } printer.writeSeparator(")").writeSpace(); scan(catchBlock.getBody()); }
@Override public <T> void visitCtAnnotationMethod(CtAnnotationMethod<T> annotationMethod) { elementPrinterHelper.writeComment(annotationMethod); elementPrinterHelper.visitCtNamedElement(annotationMethod, sourceCompilationUnit); elementPrinterHelper.writeModifiers(annotationMethod); scan(annotationMethod.getType()); printer.writeSpace(); printer.writeIdentifier(annotationMethod.getSimpleName()); printer.writeSeparator("(").writeSeparator(")"); if (annotationMethod.getDefaultExpression() != null) { printer.writeSpace().writeKeyword("default").writeSpace(); scan(annotationMethod.getDefaultExpression()); } printer.writeSeparator(";"); }
elementPrinterHelper.writeComment(comment);