/** * Set {@link TokenWriter}, which has to be used to print tokens */ public DefaultJavaPrettyPrinter setPrinterTokenWriter(TokenWriter tokenWriter) { elementPrinterHelper = new ElementPrinterHelper(tokenWriter, this, env); printer = tokenWriter; return this; }
public void writeComment(CtElement element, CommentOffset offset) { writeComment(getComments(element, offset)); }
public void visitCtNamedElement(CtNamedElement namedElement, CtCompilationUnit sourceCompilationUnit) { writeAnnotations(namedElement); if (env.isPreserveLineNumbers()) { getPrinterHelper().adjustStartPosition(namedElement); } }
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); }
@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()); }
@Override public <A extends Annotation> void visitCtAnnotation(CtAnnotation<A> annotation) { elementPrinterHelper.writeAnnotations(annotation); printer.writeSeparator("@"); scan(annotation.getAnnotationType()); if (!annotation.getValues().isEmpty()) { elementPrinterHelper.printList(annotation.getValues().entrySet(), null, false, "(", false, false, ",", true, false, ")", e -> { if ((annotation.getValues().size() == 1 && "value".equals(e.getKey())) == false) { //it is not a default value attribute. We must print a attribute name too. printer.writeIdentifier(e.getKey()).writeSpace().writeOperator("=").writeSpace(); } elementPrinterHelper.writeAnnotationElement(annotation.getFactory(), e.getValue()); }); } }
@Override public <T> void visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> reference) { elementPrinterHelper.printList(reference.getBounds(), null, false, null, false, true, "&", true, false, null, bound -> scan(bound)); }
@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()); } } }
CtTypeReference typeRef = (CtTypeReference) ctImport.getReference(); importTypeStr = typeRef.getQualifiedName(); if (!isJavaLangClasses(importTypeStr)) { setImports.add(this.removeInnerTypeSeparator(importTypeStr)); CtPackageReference packageRef = (CtPackageReference) ctImport.getReference(); importTypeStr = packageRef.getQualifiedName() + ".*"; if (!isJavaLangClasses(importTypeStr)) { setImports.add(this.removeInnerTypeSeparator(importTypeStr)); CtExecutableReference execRef = (CtExecutableReference) ctImport.getReference(); if (execRef.getDeclaringType() != null) { setStaticImports.add(this.removeInnerTypeSeparator(execRef.getDeclaringType().getQualifiedName()) + "." + execRef.getSimpleName()); setStaticImports.add(this.removeInnerTypeSeparator(fieldRef.getDeclaringType().getQualifiedName()) + "." + fieldRef.getSimpleName()); break; CtTypeMemberWildcardImportReference typeStarRef = (CtTypeMemberWildcardImportReference) ctImport.getReference(); importTypeStr = typeStarRef.getTypeReference().getQualifiedName(); if (!isJavaLangClasses(importTypeStr)) { setStaticImports.add(this.removeInnerTypeSeparator(importTypeStr)); writeQualifiedName(importLine).writeSeparator(";").writeln(); for (String importLine : sortedStaticImports) { printer.writeKeyword("import").writeSpace().writeKeyword("static").writeSpace(); writeQualifiedName(importLine).writeSeparator(";").writeln();
@Override public <T> void visitCtInterface(CtInterface<T> intrface) { visitCtType(intrface); printer.writeKeyword("interface").writeSpace().writeIdentifier(intrface.getSimpleName()); if (intrface.getFormalCtTypeParameters() != null) { elementPrinterHelper.writeFormalTypeParameters(intrface); } if (!intrface.getSuperInterfaces().isEmpty()) { elementPrinterHelper.printList(intrface.getSuperInterfaces(), "extends", false, null, false, true, ",", true, false, null, ref -> scan(ref)); } context.pushCurrentThis(intrface); printer.writeSpace().writeSeparator("{").incTab(); // Content elementPrinterHelper.writeElementList(intrface.getTypeMembers()); printer.decTab().writeSeparator("}"); context.popCurrentThis(); }
@Override public <T extends Enum<?>> void visitCtEnum(CtEnum<T> ctEnum) { visitCtType(ctEnum); printer.writeKeyword("enum").writeSpace().writeIdentifier(ctEnum.getSimpleName()); elementPrinterHelper.writeImplementsClause(ctEnum); context.pushCurrentThis(ctEnum); printer.writeSpace().writeSeparator("{").incTab().writeln(); if (ctEnum.getEnumValues().isEmpty()) { printer.writeSeparator(";").writeln(); } else { elementPrinterHelper.printList(ctEnum.getEnumValues(), null, false, null, false, false, ",", false, false, ";", enumValue -> { printer.writeln(); scan(enumValue); }); } elementPrinterHelper.writeElementList(ctEnum.getTypeMembers()); printer.decTab().writeSeparator("}"); context.popCurrentThis(); }
CtStatement thenStmt = ifElement.getThenStatement(); CtStatement elseStmt = ifElement.getElseStatement(); elementPrinterHelper.writeIfOrLoopBlock(thenStmt); if (elseStmt != null) { List<CtComment> comments = elementPrinterHelper.getComments(ifElement, CommentOffset.INSIDE); if (thenStmt != null) { SourcePosition thenPosition = thenStmt.getPosition(); elementPrinterHelper.writeComment(comment); elementPrinterHelper.writeIfOrLoopBlock(elseStmt);
elementPrinterHelper.printList(newArray.getElements(), null, false, "{", true, false, ",", true, true, "}", e -> scan(e)); elementPrinterHelper.writeComment(newArray, CommentOffset.INSIDE); elementPrinterHelper.writeComment(newArray, CommentOffset.AFTER); exitCtExpression(newArray);
private <T> void printConstructorCall(CtConstructorCall<T> ctConstructorCall) { try (Writable _context = context.modify()) { if (ctConstructorCall.getTarget() != null) { scan(ctConstructorCall.getTarget()); printer.writeSeparator("."); _context.ignoreEnclosingClass(true); } if (hasDeclaringTypeWithGenerics(ctConstructorCall.getType())) { _context.ignoreEnclosingClass(true); } printer.writeKeyword("new").writeSpace(); if (!ctConstructorCall.getActualTypeArguments().isEmpty()) { elementPrinterHelper.writeActualTypeArguments(ctConstructorCall); } scan(ctConstructorCall.getType()); } elementPrinterHelper.printList(ctConstructorCall.getArguments(), null, false, "(", false, false, ",", true, false, ")", exp -> scan(exp)); }
printer.writeLiteral("\"" + LiteralHelper.getStringLiteral((String) value, true) + "\""); } else if (value instanceof Collection) { printList((Collection<?>) value, null, false, "{", false, true, ",", false, false, "}", obj -> writeAnnotationElement(factory, obj)); } else if (value instanceof Object[]) { printList(Arrays.asList((Object[]) value), null, false, "{", false, true, ",", false, false, "}", obj -> writeAnnotationElement(factory, obj)); } else if (value instanceof Enum) { try (Writable c = prettyPrinter.getContext().modify().ignoreGenerics(true)) {
printer.writeSpace(); elementPrinterHelper.printList(forLoop.getForUpdate(), null, false, null, false, true, ",", true, false, null, s -> scan(s)); printer.writeSeparator(")"); elementPrinterHelper.writeIfOrLoopBlock(forLoop.getBody()); exitCtStatement(forLoop);
elementPrinterHelper.writeAnnotations(ref); printer.writeKeyword(ref.getSimpleName()); return; elementPrinterHelper.writeAnnotations(ref); if (ref.isLocalType()) { printer.writeIdentifier(ref.getSimpleName().replaceAll("^[0-9]*", "")); elementPrinterHelper.writeAnnotations(ref); printer.writeIdentifier(ref.getSimpleName()); elementPrinterHelper.writeActualTypeArguments(ref);
printer.writeSpace().writeKeyword(startKeyword).writeSpace(); try (spoon.reflect.visitor.ListPrinter lp = createListPrinter( startPrefixSpace, start, startSuffixSpace, nextPrefixSpace, next, nextSuffixSpace,
@Override public <T> void visitCtMethod(CtMethod<T> m) { elementPrinterHelper.writeComment(m, CommentOffset.BEFORE); elementPrinterHelper.visitCtNamedElement(m, sourceCompilationUnit); elementPrinterHelper.writeModifiers(m); elementPrinterHelper.writeFormalTypeParameters(m); if (!m.getFormalCtTypeParameters().isEmpty()) { printer.writeSpace(); elementPrinterHelper.writeExecutableParameters(m); elementPrinterHelper.writeThrowsClause(m); if (m.getBody() != null) { printer.writeSpace(); printer.writeSeparator(";"); elementPrinterHelper.writeComment(m, CommentOffset.AFTER);
@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); }