@Override public String toString() { DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(getFactory().getEnvironment()); String errorMessage = ""; try { // we do not want to compute imports of for CtImport and CtReference // as it may change the print of a reference if (!(this instanceof CtImport) && !(this instanceof CtReference)) { printer.getImportsContext().computeImports(this); } printer.scan(this); } catch (ParentNotInitializedException ignore) { LOGGER.error(ERROR_MESSAGE_TO_STRING, ignore); errorMessage = ERROR_MESSAGE_TO_STRING; } // in line-preservation mode, newlines are added at the beginning to matches the lines // removing them from the toString() representation return printer.toString().replaceFirst("^\\s+", "") + errorMessage; }
@Override public void calculate(CtCompilationUnit sourceCompilationUnit, List<CtType<?>> types) { // reset the importsContext to avoid errors with multiple CU reset(); this.sourceCompilationUnit = sourceCompilationUnit; this.imports = new HashSet<>(); if (sourceCompilationUnit != null) { this.importsContext.initWithImports(sourceCompilationUnit.getImports()); } for (CtType<?> t : types) { imports.addAll(computeImports(t)); } this.writeHeader(types, imports); printTypes(types); }
@Override public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) { enterCtStatement(ctConstructorCall); enterCtExpression(ctConstructorCall); printConstructorCall(ctConstructorCall); exitCtExpression(ctConstructorCall); exitCtStatement(ctConstructorCall); }
@Override public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) { if (typeAccess.isImplicit()) { return; } enterCtExpression(typeAccess); scan(typeAccess.getAccessedType()); exitCtExpression(typeAccess); }
public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> assignement) { enterCtStatement(assignement); enterCtExpression(assignement); scan(assignement.getAssigned()); write(" = "); scan(assignement.getAssignment()); exitCtExpression(assignement); }
@Override public void visitCtThrow(CtThrow throwStatement) { enterCtStatement(throwStatement); printer.writeKeyword("throw").writeSpace(); scan(throwStatement.getThrownExpression()); exitCtStatement(throwStatement); }
@Override public String toString() { DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter( getFactory().getEnvironment()); printer.scan(this); return printer.toString(); }
@Override public void visitCtStatementList(CtStatementList statements) { for (CtStatement s : statements.getStatements()) { scan(s); } }
@Override public String toString() { DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(getFactory().getEnvironment()); String errorMessage = ""; try { printer.computeImports(this); printer.scan(this); } catch (ParentNotInitializedException ignore) { errorMessage = ERROR_MESSAGE_TO_STRING; } return printer.toString() + errorMessage; }
@Override public PrettyPrinter createPrettyPrinter() { if (prettyPrinterCreator == null) { // DJPP is the default mode // fully backward compatible return new DefaultJavaPrettyPrinter(this); } return prettyPrinterCreator.get(); }
@Override public <T> void visitCtInvocation(CtInvocation<T> invocation) { enterCtStatement(invocation); enterCtExpression(invocation); if (invocation.getExecutable().isConstructor()) { } else { if (invocation.getTarget() != null && !invocation.getTarget().isImplicit()) { scan(invocation.getTarget()); printer.writeSeparator("."); boolean isImported = this.isImported(invocation.getExecutable()); if (!isImported) { try (Writable _context = context.modify()) { scan(invocation.getTarget()); printer.writeSeparator("."); getPrinterHelper().adjustStartPosition(invocation); e -> scan(e)); exitCtExpression(invocation); exitCtStatement(invocation);
public <T> void visitCtTypeReference(CtTypeReference<T> ref) { if (ref.isPrimitive()) { write(ref.getSimpleName()); return; } if (importsContext.isImported(ref) && ref.getPackage() != null) { printTypeAnnotations(ref); write(ref.getSimpleName()); } else { if (ref.getDeclaringType() != null) { if (!context.currentThis.contains(ref.getDeclaringType()) || ref.getModifiers().contains(ModifierKind.STATIC) || hasDeclaringTypeWithGenerics(ref)) { if (!context.ignoreEnclosingClass) { boolean ign = context.ignoreGenerics; context.ignoreGenerics = false; scan(ref.getDeclaringType()); write("."); context.ignoreGenerics = ign; } } write(ref.getSimpleName()); } else { write(ref.getQualifiedName()); } } if (!context.ignoreGenerics) { writeActualTypeArguments(ref); } }
public <R> void visitCtReturn(CtReturn<R> returnStatement) { enterCtStatement(returnStatement); write("return "); scan(returnStatement.getReturnedExpression()); }
public <T> void visitCtUnaryOperator(CtUnaryOperator<T> operator) { enterCtStatement(operator); enterCtExpression(operator); preWriteUnaryOperator(operator.getKind()); context.enterTarget(); scan(operator.getOperand()); context.exitTarget(); postWriteUnaryOperator(operator.getKind()); exitCtExpression(operator); }
private <T> void printCtFieldAccess(CtFieldAccess<T> f) { enterCtExpression(f); try (Writable _context = context.modify()) { if ((f.getVariable().isStatic() || "class".equals(f.getVariable().getSimpleName())) && f.getTarget() instanceof CtTypeAccess) { boolean isInitializeStaticFinalField = isInitializeStaticFinalField(f.getTarget()); boolean isStaticField = f.getVariable().isStatic(); boolean isImportedField = this.isImported(f.getVariable()); scan(target); printer.writeSeparator("."); scan(f.getVariable()); exitCtExpression(f);
public void calculate(CompilationUnit sourceCompilationUnit, List<CtType<?>> types) { this.sourceCompilationUnit = sourceCompilationUnit; Collection<CtTypeReference<?>> imports = Collections.emptyList(); for (CtType<?> t : types) { imports = computeImports(t); } writeHeader(types, imports); for (CtType<?> t : types) { scan(t); writeln().writeln().writeTabs(); } }
@Override public <T> void visitCtLocalVariable(CtLocalVariable<T> localVariable) { enterCtStatement(localVariable); if (env.isPreserveLineNumbers()) { getPrinterHelper().adjustStartPosition(localVariable); } if (!context.isNextForVariable()) { elementPrinterHelper.writeModifiers(localVariable); if (localVariable.isInferred() && this.env.getComplianceLevel() >= 10) { getPrinterTokenWriter().writeKeyword("var"); } else { scan(localVariable.getType()); } printer.writeSpace(); } printer.writeIdentifier(localVariable.getSimpleName()); if (localVariable.getDefaultExpression() != null) { printer.writeSpace().writeOperator("=").writeSpace(); scan(localVariable.getDefaultExpression()); } exitCtStatement(localVariable); }
@Override public char[] getContents() { DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(type.getFactory().getEnvironment()); List<CtType<?>> types = new ArrayList<>(); types.add(type); printer.calculate(type.getPosition().getCompilationUnit(), types); return printer.getResult().toCharArray(); } }
private String partialElementPrint(CtElement element) { DefaultJavaPrettyPrinter print = new DefaultJavaPrettyPrinter(element.getFactory().getEnvironment()) { @Override public DefaultJavaPrettyPrinter scan(CtElement e) { if (e != null && e.getMetadata("isMoved") == null) { return super.scan(e); } return this; } }; print.scan(element); return print.getResult(); }