#3996

Committed 04 Apr 2024 06:04PM UTC coverage: 48.722% (+0.01%) from 48.711%

Build # #3996

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4927 from oowekyala/fix-pretty-printing

[java] More pretty printing fixes

Run Details

32443 of 72899 branches covered (44.5%)

Branch coverage included in aggregate %.

43 of 43 new or added lines in 2 files covered. (100.0%)

8 existing lines in 2 files now uncovered.

68266 of 133803 relevant lines covered (51.02%)

0.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.86

/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/ast/internal/PrettyPrintingUtil.java

/*
 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
 */

package net.sourceforge.pmd.lang.java.ast.internal;

import static net.sourceforge.pmd.lang.java.rule.codestyle.UselessParenthesesRule.Necessity;
import static net.sourceforge.pmd.lang.java.rule.codestyle.UselessParenthesesRule.needsParentheses;
import static net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere;

import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

import net.sourceforge.pmd.lang.java.ast.ASTAmbiguousName;
import net.sourceforge.pmd.lang.java.ast.ASTAnnotationTypeDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTArgumentList;
import net.sourceforge.pmd.lang.java.ast.ASTArrayAccess;
import net.sourceforge.pmd.lang.java.ast.ASTArrayType;
import net.sourceforge.pmd.lang.java.ast.ASTCastExpression;
import net.sourceforge.pmd.lang.java.ast.ASTClassDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTClassLiteral;
import net.sourceforge.pmd.lang.java.ast.ASTClassType;
import net.sourceforge.pmd.lang.java.ast.ASTConditionalExpression;
import net.sourceforge.pmd.lang.java.ast.ASTConstructorCall;
import net.sourceforge.pmd.lang.java.ast.ASTConstructorDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTEnumDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTExecutableDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTExpression;
import net.sourceforge.pmd.lang.java.ast.ASTFieldAccess;
import net.sourceforge.pmd.lang.java.ast.ASTFieldDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTFormalParameter;
import net.sourceforge.pmd.lang.java.ast.ASTFormalParameters;
import net.sourceforge.pmd.lang.java.ast.ASTImportDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTInfixExpression;
import net.sourceforge.pmd.lang.java.ast.ASTIntersectionType;
import net.sourceforge.pmd.lang.java.ast.ASTLambdaExpression;
import net.sourceforge.pmd.lang.java.ast.ASTLambdaParameterList;
import net.sourceforge.pmd.lang.java.ast.ASTList;
import net.sourceforge.pmd.lang.java.ast.ASTLiteral;
import net.sourceforge.pmd.lang.java.ast.ASTMethodCall;
import net.sourceforge.pmd.lang.java.ast.ASTMethodDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTMethodReference;
import net.sourceforge.pmd.lang.java.ast.ASTPrimitiveType;
import net.sourceforge.pmd.lang.java.ast.ASTRecordDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTReferenceType;
import net.sourceforge.pmd.lang.java.ast.ASTResource;
import net.sourceforge.pmd.lang.java.ast.ASTSuperExpression;
import net.sourceforge.pmd.lang.java.ast.ASTThisExpression;
import net.sourceforge.pmd.lang.java.ast.ASTType;
import net.sourceforge.pmd.lang.java.ast.ASTTypeArguments;
import net.sourceforge.pmd.lang.java.ast.ASTTypeDeclaration;
import net.sourceforge.pmd.lang.java.ast.ASTTypeExpression;
import net.sourceforge.pmd.lang.java.ast.ASTUnaryExpression;
import net.sourceforge.pmd.lang.java.ast.ASTUnionType;
import net.sourceforge.pmd.lang.java.ast.ASTVariableAccess;
import net.sourceforge.pmd.lang.java.ast.ASTVariableId;
import net.sourceforge.pmd.lang.java.ast.ASTVoidType;
import net.sourceforge.pmd.lang.java.ast.ASTWildcardType;
import net.sourceforge.pmd.lang.java.ast.JavaNode;
import net.sourceforge.pmd.lang.java.ast.JavaVisitorBase;
import net.sourceforge.pmd.lang.java.ast.QualifiableExpression;
import net.sourceforge.pmd.lang.java.symbols.JMethodSymbol;
import net.sourceforge.pmd.lang.java.types.JMethodSig;
import net.sourceforge.pmd.lang.java.types.TypePrettyPrint;
import net.sourceforge.pmd.lang.java.types.TypePrettyPrint.TypePrettyPrinter;
import net.sourceforge.pmd.util.CollectionUtil;

/**
 * @author Clément Fournier
 */
public final class PrettyPrintingUtil {

    private PrettyPrintingUtil() {
        // util class
    }

    /**
     * Returns a normalized method name. This just looks at the image of the types of the parameters.
     */
    public static String displaySignature(String methodName, ASTFormalParameters params) {

        StringBuilder sb = new StringBuilder();
        sb.append(methodName);
        sb.append('(');

        boolean first = true;
        for (ASTFormalParameter param : params) {
            if (!first) {
                sb.append(", ");
            }
            first = false;

            prettyPrintTypeNode(sb, param.getTypeNode());
            int extraDimensions = ASTList.sizeOrZero(param.getVarId().getExtraDimensions());
            while (extraDimensions-- > 0) {
                sb.append("[]");
            }
        }

        sb.append(')');

        return sb.toString();
    }

    private static void prettyPrintTypeNode(StringBuilder sb, ASTType t) {
        if (t instanceof ASTPrimitiveType) {
            sb.append(((ASTPrimitiveType) t).getKind().getSimpleName());
        } else if (t instanceof ASTClassType) {
            ASTClassType classT = (ASTClassType) t;
            sb.append(classT.getSimpleName());

            ASTTypeArguments targs = classT.getTypeArguments();
            if (targs != null) {
                sb.append("<");
                CollectionUtil.joinOn(sb, targs.toStream(), PrettyPrintingUtil::prettyPrintTypeNode, ", ");
                sb.append(">");
            }
        } else if (t instanceof ASTArrayType) {
            prettyPrintTypeNode(sb, ((ASTArrayType) t).getElementType());
            int depth = ((ASTArrayType) t).getArrayDepth();
            for (int i = 0; i < depth; i++) {
                sb.append("[]");
            }
        } else if (t instanceof ASTVoidType) {
            sb.append("void");
        } else if (t instanceof ASTWildcardType) {
            sb.append("?");
            ASTReferenceType bound = ((ASTWildcardType) t).getTypeBoundNode();
            if (bound != null) {
                sb.append(((ASTWildcardType) t).isLowerBound() ? " super " : " extends ");
                prettyPrintTypeNode(sb, bound);
            }
        } else if (t instanceof ASTUnionType) {
            CollectionUtil.joinOn(sb, ((ASTUnionType) t).getComponents(),
                PrettyPrintingUtil::prettyPrintTypeNode, " | ");
        } else if (t instanceof ASTIntersectionType) {
            CollectionUtil.joinOn(sb, ((ASTIntersectionType) t).getComponents(),
                PrettyPrintingUtil::prettyPrintTypeNode, " & ");
        } else if (t instanceof ASTAmbiguousName) {
            sb.append(((ASTAmbiguousName) t).getName());
        } else {
            throw shouldNotReachHere("Unhandled type? " + t);
        }
    }

    public static String prettyPrintType(ASTType t) {
        StringBuilder sb = new StringBuilder();
        prettyPrintTypeNode(sb, t);
        return sb.toString();
    }

    /**
     * Returns a normalized method name. This just looks at the image of the types of the parameters.
     */
    public static String displaySignature(ASTExecutableDeclaration node) {
        return displaySignature(node.getName(), node.getFormalParameters());
    }

    /**
     * Returns the generic kind of declaration this is, eg "enum" or "class".
     */
    public static String getPrintableNodeKind(ASTTypeDeclaration decl) {
        if (decl instanceof ASTClassDeclaration && decl.isInterface()) {
            return "interface";
        } else if (decl instanceof ASTAnnotationTypeDeclaration) {
            return "annotation";
        } else if (decl instanceof ASTEnumDeclaration) {
            return "enum";
        } else if (decl instanceof ASTRecordDeclaration) {
            return "record";
        }
        return "class";
    }

    /**
     * Returns the "name" of a node. For methods and constructors, this
     * may return a signature with parameters.
     */
    public static String getNodeName(JavaNode node) {
        // constructors are differentiated by their parameters, while we only use method name for methods
        if (node instanceof ASTMethodDeclaration) {
            return ((ASTMethodDeclaration) node).getName();
        } else if (node instanceof ASTExecutableDeclaration) {
            // constructors are differentiated by their parameters, while we only use method name for methods
            return displaySignature((ASTConstructorDeclaration) node);
        } else if (node instanceof ASTFieldDeclaration) {
            return ((ASTFieldDeclaration) node).getVarIds().firstOrThrow().getName();
        } else if (node instanceof ASTResource) {
            return ((ASTResource) node).getStableName();
        } else if (node instanceof ASTTypeDeclaration) {
            return ((ASTTypeDeclaration) node).getSimpleName();
        } else if (node instanceof ASTVariableId) {
            return ((ASTVariableId) node).getName();
        } else {
            throw new IllegalArgumentException("Node has no defined name: " + node);
        }
    }


    /**
     * Returns the 'kind' of node this is. For instance for a {@link ASTFieldDeclaration},
     * returns "field".
     *
     * @throws UnsupportedOperationException If unimplemented for a node kind
     * @see #getPrintableNodeKind(ASTTypeDeclaration)
     */
    public static String getPrintableNodeKind(JavaNode node) {
        if (node instanceof ASTTypeDeclaration) {
            return getPrintableNodeKind((ASTTypeDeclaration) node);
        } else if (node instanceof ASTMethodDeclaration) {
            return "method";
        } else if (node instanceof ASTConstructorDeclaration) {
            return "constructor";
        } else if (node instanceof ASTFieldDeclaration) {
            return "field";
        } else if (node instanceof ASTResource) {
            return "resource specification";
        }
        throw new UnsupportedOperationException("Node " + node + " is unaccounted for");
    }

    public static String prettyImport(ASTImportDeclaration importDecl) {
        String name = importDecl.getImportedName();
        if (importDecl.isImportOnDemand()) {
            return name + ".*";
        }
        return name;
    }

    /**
     * Pretty print the selected overload.
     */
    public static @NonNull String prettyPrintOverload(ASTMethodCall it) {
        return prettyPrintOverload(it.getOverloadSelectionInfo().getMethodType());
    }

    public static @NonNull String prettyPrintOverload(JMethodSymbol it) {
        return prettyPrintOverload(it.getTypeSystem().sigOf(it));
    }

    public static @NonNull String prettyPrintOverload(JMethodSig it) {
        return TypePrettyPrint.prettyPrint(it, overloadPrinter());
    }

    private static TypePrettyPrinter overloadPrinter() {
        return new TypePrettyPrinter().qualifyNames(false).printMethodResult(false);
    }


    public static CharSequence prettyPrint(JavaNode node) {
        StringBuilder sb = new StringBuilder();
        node.acceptVisitor(new ExprPrinter(), sb);
        return sb;
    }

    static class ExprPrinter extends JavaVisitorBase<StringBuilder, Void> {

        private static final int MAX_ARG_LENGTH = 20;

        @Override
        public Void visitJavaNode(JavaNode node, StringBuilder data) {
            data.append("<<NOT_IMPLEMENTED: ").append(node).append(">>");
            return null; // don't recurse
        }

        @Override
        public Void visit(ASTTypeExpression node, StringBuilder data) {
            node.getTypeNode().acceptVisitor(this, data);
            return null;
        }

        @Override
        public Void visit(ASTCastExpression node, StringBuilder data) {
            ppInParens(data, node.getCastType()).append(' ');
            node.getOperand().acceptVisitor(this, data);
            return null;
        }

        @Override
        public Void visit(ASTClassLiteral node, StringBuilder data) {
            node.getTypeNode().acceptVisitor(this, data);
            data.append(".class");
            return null;
        }

        @Override
        public Void visitLiteral(ASTLiteral node, StringBuilder data) {
            data.append(node.getText());
            return null;
        }

        @Override
        public Void visit(ASTFieldAccess node, StringBuilder data) {
            addQualifier(node, data);
            data.append(node.getName());
            return null;
        }

        @Override
        public Void visit(ASTVariableAccess node, StringBuilder data) {
            data.append(node.getName());
            return null;
        }

        @Override
        public Void visit(ASTThisExpression node, StringBuilder data) {
            if (node.getQualifier() != null) {
                node.getQualifier().acceptVisitor(this, data);
                data.append('.');
            }
            data.append("this");
            return null;
        }

        @Override
        public Void visit(ASTSuperExpression node, StringBuilder data) {
            if (node.getQualifier() != null) {
                node.getQualifier().acceptVisitor(this, data);
                data.append('.');
            }
            data.append("super");
            return null;
        }

        @Override
        public Void visit(ASTArrayAccess node, StringBuilder data) {
            node.getQualifier().acceptVisitor(this, data);
            data.append('[');
            node.getIndexExpression().acceptVisitor(this, data);
            data.append(']');
            return null;
        }

        @Override
        public Void visitType(ASTType node, StringBuilder data) {
            prettyPrintTypeNode(data, node);
            return null;
        }

        @Override
        public Void visit(ASTAmbiguousName node, StringBuilder data) {
            data.append(node.getName());
            return null;
        }

        @Override
        public Void visit(ASTInfixExpression node, StringBuilder sb) {
            printWithParensIfNecessary(node.getLeftOperand(), sb, node);
            sb.append(' ');
            sb.append(node.getOperator());
            sb.append(' ');
            printWithParensIfNecessary(node.getRightOperand(), sb, node);
            return null;
        }


        @Override
        public Void visit(ASTUnaryExpression node, StringBuilder sb) {
            sb.append(node.getOperator());
            printWithParensIfNecessary(node.getOperand(), sb, node);
            return null;
        }

        private void printWithParensIfNecessary(ASTExpression operand, StringBuilder sb, ASTExpression parent) {
            if (operand.isParenthesized() && needsParentheses(operand, parent) != Necessity.NEVER) {
                ppInParens(sb, operand);
            } else {
                operand.acceptVisitor(this, sb);
            }
        }

        @Override
        public Void visit(ASTConditionalExpression node, StringBuilder sb) {
            printWithParensIfNecessary(node.getCondition(), sb, node);
            sb.append(" ? ");
            printWithParensIfNecessary(node.getThenBranch(), sb, node);
            sb.append(" : ");
            printWithParensIfNecessary(node.getElseBranch(), sb, node);
            return null;
        }

        @Override
        public Void visit(ASTLambdaExpression node, StringBuilder sb) {
            node.getParameters().acceptVisitor(this, sb);
            sb.append(" -> ");
            ASTExpression exprBody = node.getExpression();
            if (exprBody != null) {
                exprBody.acceptVisitor(this, sb);
            } else {
                sb.append("{ ... }");
            }
            return null;
        }

        @Override
        public Void visit(ASTLambdaParameterList node, StringBuilder sb) {
            if (node.size() == 1) {
                sb.append(node.get(0).getVarId().getName());
                return null;
            } else if (node.isEmpty()) {
                sb.append("()");
                return null;
            }

            sb.append('(');
            sb.append(node.get(0).getVarId().getName());
            node.toStream().drop(1).forEach(it -> {
                sb.append(", ");
                sb.append(it.getVarId().getName());
            });
            sb.append(')');

            return null;
        }

        @Override
        public Void visit(ASTMethodCall node, StringBuilder sb) {
            addQualifier(node, sb);
            ppTypeArgs(sb, node.getExplicitTypeArguments());
            sb.append(node.getMethodName());
            ppArguments(sb, node.getArguments());
            return null;
        }

        @Override
        public Void visit(ASTConstructorCall node, StringBuilder sb) {
            addQualifier(node, sb);
            sb.append("new ");
            ppTypeArgs(sb, node.getExplicitTypeArguments());
            prettyPrintTypeNode(sb, node.getTypeNode());
            ppArguments(sb, node.getArguments());
            return null;
        }

        private void ppArguments(StringBuilder sb, ASTArgumentList arguments) {
            if (arguments.isEmpty()) {
                sb.append("()");
            } else {
                final int argStart = sb.length();
                sb.append('(');
                boolean first = true;
                for (ASTExpression arg : arguments) {
                    if (sb.length() - argStart >= MAX_ARG_LENGTH) {
                        sb.append("...");
                        break;
                    } else if (!first) {
                        sb.append(", ");
                    }
                    arg.acceptVisitor(this, sb);
                    first = false;
                }
                sb.append(')');
            }
        }

        @Override
        public Void visit(ASTMethodReference node, StringBuilder sb) {
            printWithParensIfNecessary(node.getQualifier(), sb, node);
            sb.append("::");
            ppTypeArgs(sb, node.getExplicitTypeArguments());
            sb.append(node.getMethodName());
            return null;
        }

        private void addQualifier(QualifiableExpression node, StringBuilder data) {
            ASTExpression qualifier = node.getQualifier();
            if (qualifier != null) {
                printWithParensIfNecessary(qualifier, data, node);
                data.append('.');
            }

        }

        private StringBuilder ppInParens(StringBuilder data, JavaNode qualifier) {
            data.append('(');
            qualifier.acceptVisitor(this, data);
            return data.append(')');
        }


        private void ppTypeArgs(StringBuilder data, @Nullable ASTTypeArguments targs) {
            if (targs == null) {
                return;
            }
            data.append('<');
            prettyPrintTypeNode(data, targs.get(0));
            for (int i = 1; i < targs.size(); i++) {
                data.append(", ");
                prettyPrintTypeNode(data, targs.get(i));
            }
            data.append('>');
        }

    }


}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.lang.java.ast.internal;
6
7	import static net.sourceforge.pmd.lang.java.rule.codestyle.UselessParenthesesRule.Necessity;
8	import static net.sourceforge.pmd.lang.java.rule.codestyle.UselessParenthesesRule.needsParentheses;
9	import static net.sourceforge.pmd.util.AssertionUtil.shouldNotReachHere;
10
11	import org.checkerframework.checker.nullness.qual.NonNull;
12	import org.checkerframework.checker.nullness.qual.Nullable;
13
14	import net.sourceforge.pmd.lang.java.ast.ASTAmbiguousName;
15	import net.sourceforge.pmd.lang.java.ast.ASTAnnotationTypeDeclaration;
16	import net.sourceforge.pmd.lang.java.ast.ASTArgumentList;
17	import net.sourceforge.pmd.lang.java.ast.ASTArrayAccess;
18	import net.sourceforge.pmd.lang.java.ast.ASTArrayType;
19	import net.sourceforge.pmd.lang.java.ast.ASTCastExpression;
20	import net.sourceforge.pmd.lang.java.ast.ASTClassDeclaration;
21	import net.sourceforge.pmd.lang.java.ast.ASTClassLiteral;
22	import net.sourceforge.pmd.lang.java.ast.ASTClassType;
23	import net.sourceforge.pmd.lang.java.ast.ASTConditionalExpression;
24	import net.sourceforge.pmd.lang.java.ast.ASTConstructorCall;
25	import net.sourceforge.pmd.lang.java.ast.ASTConstructorDeclaration;
26	import net.sourceforge.pmd.lang.java.ast.ASTEnumDeclaration;
27	import net.sourceforge.pmd.lang.java.ast.ASTExecutableDeclaration;
28	import net.sourceforge.pmd.lang.java.ast.ASTExpression;
29	import net.sourceforge.pmd.lang.java.ast.ASTFieldAccess;
30	import net.sourceforge.pmd.lang.java.ast.ASTFieldDeclaration;
31	import net.sourceforge.pmd.lang.java.ast.ASTFormalParameter;
32	import net.sourceforge.pmd.lang.java.ast.ASTFormalParameters;
33	import net.sourceforge.pmd.lang.java.ast.ASTImportDeclaration;
34	import net.sourceforge.pmd.lang.java.ast.ASTInfixExpression;
35	import net.sourceforge.pmd.lang.java.ast.ASTIntersectionType;
36	import net.sourceforge.pmd.lang.java.ast.ASTLambdaExpression;
37	import net.sourceforge.pmd.lang.java.ast.ASTLambdaParameterList;
38	import net.sourceforge.pmd.lang.java.ast.ASTList;
39	import net.sourceforge.pmd.lang.java.ast.ASTLiteral;
40	import net.sourceforge.pmd.lang.java.ast.ASTMethodCall;
41	import net.sourceforge.pmd.lang.java.ast.ASTMethodDeclaration;
42	import net.sourceforge.pmd.lang.java.ast.ASTMethodReference;
43	import net.sourceforge.pmd.lang.java.ast.ASTPrimitiveType;
44	import net.sourceforge.pmd.lang.java.ast.ASTRecordDeclaration;
45	import net.sourceforge.pmd.lang.java.ast.ASTReferenceType;
46	import net.sourceforge.pmd.lang.java.ast.ASTResource;
47	import net.sourceforge.pmd.lang.java.ast.ASTSuperExpression;
48	import net.sourceforge.pmd.lang.java.ast.ASTThisExpression;
49	import net.sourceforge.pmd.lang.java.ast.ASTType;
50	import net.sourceforge.pmd.lang.java.ast.ASTTypeArguments;
51	import net.sourceforge.pmd.lang.java.ast.ASTTypeDeclaration;
52	import net.sourceforge.pmd.lang.java.ast.ASTTypeExpression;
53	import net.sourceforge.pmd.lang.java.ast.ASTUnaryExpression;
54	import net.sourceforge.pmd.lang.java.ast.ASTUnionType;
55	import net.sourceforge.pmd.lang.java.ast.ASTVariableAccess;
56	import net.sourceforge.pmd.lang.java.ast.ASTVariableId;
57	import net.sourceforge.pmd.lang.java.ast.ASTVoidType;
58	import net.sourceforge.pmd.lang.java.ast.ASTWildcardType;
59	import net.sourceforge.pmd.lang.java.ast.JavaNode;
60	import net.sourceforge.pmd.lang.java.ast.JavaVisitorBase;
61	import net.sourceforge.pmd.lang.java.ast.QualifiableExpression;
62	import net.sourceforge.pmd.lang.java.symbols.JMethodSymbol;
63	import net.sourceforge.pmd.lang.java.types.JMethodSig;
64	import net.sourceforge.pmd.lang.java.types.TypePrettyPrint;
65	import net.sourceforge.pmd.lang.java.types.TypePrettyPrint.TypePrettyPrinter;
66	import net.sourceforge.pmd.util.CollectionUtil;
67
68	/**
69	* @author Clément Fournier
70	*/
71	public final class PrettyPrintingUtil {
72
73	private PrettyPrintingUtil() {
74	// util class
75	}
76
77	/**
78	* Returns a normalized method name. This just looks at the image of the types of the parameters.
79	*/
80	public static String displaySignature(String methodName, ASTFormalParameters params) {
81
82	StringBuilder sb = new StringBuilder();	1✔
83	sb.append(methodName);	1✔
84	sb.append('(');	1✔
85
86	boolean first = true;	1✔
87	for (ASTFormalParameter param : params) {	1✔
88	if (!first) {	1✔
89	sb.append(", ");	1✔
90	}
91	first = false;	1✔
92
93	prettyPrintTypeNode(sb, param.getTypeNode());	1✔
94	int extraDimensions = ASTList.sizeOrZero(param.getVarId().getExtraDimensions());	1✔
95	while (extraDimensions-- > 0) {	1✔
96	sb.append("[]");	1✔
97	}
98	}	1✔
99
100	sb.append(')');	1✔
101
102	return sb.toString();	1✔
103	}
104
105	private static void prettyPrintTypeNode(StringBuilder sb, ASTType t) {
106	if (t instanceof ASTPrimitiveType) {	1✔
107	sb.append(((ASTPrimitiveType) t).getKind().getSimpleName());	1✔
108	} else if (t instanceof ASTClassType) {	1✔
109	ASTClassType classT = (ASTClassType) t;	1✔
110	sb.append(classT.getSimpleName());	1✔
111
112	ASTTypeArguments targs = classT.getTypeArguments();	1✔
113	if (targs != null) {	1✔
114	sb.append("<");	1✔
115	CollectionUtil.joinOn(sb, targs.toStream(), PrettyPrintingUtil::prettyPrintTypeNode, ", ");	1✔
116	sb.append(">");	1✔
117	}
118	} else if (t instanceof ASTArrayType) {	1✔
119	prettyPrintTypeNode(sb, ((ASTArrayType) t).getElementType());	1✔
120	int depth = ((ASTArrayType) t).getArrayDepth();	1✔
121	for (int i = 0; i < depth; i++) {	1✔
122	sb.append("[]");	1✔
123	}
124	} else if (t instanceof ASTVoidType) {	1!
125	sb.append("void");	×
126	} else if (t instanceof ASTWildcardType) {	1!
127	sb.append("?");	1✔
128	ASTReferenceType bound = ((ASTWildcardType) t).getTypeBoundNode();	1✔
129	if (bound != null) {	1✔
130	sb.append(((ASTWildcardType) t).isLowerBound() ? " super " : " extends ");	1✔
131	prettyPrintTypeNode(sb, bound);	1✔
132	}
133	} else if (t instanceof ASTUnionType) {	1!
134	CollectionUtil.joinOn(sb, ((ASTUnionType) t).getComponents(),	×
135	PrettyPrintingUtil::prettyPrintTypeNode, " \| ");
136	} else if (t instanceof ASTIntersectionType) {	×
137	CollectionUtil.joinOn(sb, ((ASTIntersectionType) t).getComponents(),	×
138	PrettyPrintingUtil::prettyPrintTypeNode, " & ");
139	} else if (t instanceof ASTAmbiguousName) {	×
140	sb.append(((ASTAmbiguousName) t).getName());	×
141	} else {
142	throw shouldNotReachHere("Unhandled type? " + t);	×
143	}
144	}	1✔
145
146	public static String prettyPrintType(ASTType t) {
147	StringBuilder sb = new StringBuilder();	1✔
148	prettyPrintTypeNode(sb, t);	1✔
149	return sb.toString();	1✔
150	}
151
152	/**
153	* Returns a normalized method name. This just looks at the image of the types of the parameters.
154	*/
155	public static String displaySignature(ASTExecutableDeclaration node) {
156	return displaySignature(node.getName(), node.getFormalParameters());	1✔
157	}
158
159	/**
160	* Returns the generic kind of declaration this is, eg "enum" or "class".
161	*/
162	public static String getPrintableNodeKind(ASTTypeDeclaration decl) {
163	if (decl instanceof ASTClassDeclaration && decl.isInterface()) {	1✔
164	return "interface";	1✔
165	} else if (decl instanceof ASTAnnotationTypeDeclaration) {	1✔
166	return "annotation";	1✔
167	} else if (decl instanceof ASTEnumDeclaration) {	1✔
168	return "enum";	1✔
169	} else if (decl instanceof ASTRecordDeclaration) {	1✔
170	return "record";	1✔
171	}
172	return "class";	1✔
173	}
174
175	/**
176	* Returns the "name" of a node. For methods and constructors, this
177	* may return a signature with parameters.
178	*/
179	public static String getNodeName(JavaNode node) {
180	// constructors are differentiated by their parameters, while we only use method name for methods
181	if (node instanceof ASTMethodDeclaration) {	1✔
182	return ((ASTMethodDeclaration) node).getName();	1✔
183	} else if (node instanceof ASTExecutableDeclaration) {	1✔
184	// constructors are differentiated by their parameters, while we only use method name for methods
185	return displaySignature((ASTConstructorDeclaration) node);	1✔
186	} else if (node instanceof ASTFieldDeclaration) {	1✔
187	return ((ASTFieldDeclaration) node).getVarIds().firstOrThrow().getName();	1✔
188	} else if (node instanceof ASTResource) {	1✔
189	return ((ASTResource) node).getStableName();	1✔
190	} else if (node instanceof ASTTypeDeclaration) {	1!
191	return ((ASTTypeDeclaration) node).getSimpleName();	1✔
192	} else if (node instanceof ASTVariableId) {	×
193	return ((ASTVariableId) node).getName();	×
194	} else {
195	throw new IllegalArgumentException("Node has no defined name: " + node);	×
196	}
197	}
198
199
200	/**
201	* Returns the 'kind' of node this is. For instance for a {@link ASTFieldDeclaration},
202	* returns "field".
203	*
204	* @throws UnsupportedOperationException If unimplemented for a node kind
205	* @see #getPrintableNodeKind(ASTTypeDeclaration)
206	*/
207	public static String getPrintableNodeKind(JavaNode node) {
208	if (node instanceof ASTTypeDeclaration) {	1✔
209	return getPrintableNodeKind((ASTTypeDeclaration) node);	1✔
210	} else if (node instanceof ASTMethodDeclaration) {	1✔
211	return "method";	1✔
212	} else if (node instanceof ASTConstructorDeclaration) {	1✔
213	return "constructor";	1✔
214	} else if (node instanceof ASTFieldDeclaration) {	1✔
215	return "field";	1✔
216	} else if (node instanceof ASTResource) {	1!
217	return "resource specification";	1✔
218	}
219	throw new UnsupportedOperationException("Node " + node + " is unaccounted for");	×
220	}
221
222	public static String prettyImport(ASTImportDeclaration importDecl) {
223	String name = importDecl.getImportedName();	1✔
224	if (importDecl.isImportOnDemand()) {	1✔
225	return name + ".*";	1✔
226	}
227	return name;	1✔
228	}
229
230	/**
231	* Pretty print the selected overload.
232	*/
233	public static @NonNull String prettyPrintOverload(ASTMethodCall it) {
234	return prettyPrintOverload(it.getOverloadSelectionInfo().getMethodType());	×
235	}
236
237	public static @NonNull String prettyPrintOverload(JMethodSymbol it) {
238	return prettyPrintOverload(it.getTypeSystem().sigOf(it));	1✔
239	}
240
241	public static @NonNull String prettyPrintOverload(JMethodSig it) {
242	return TypePrettyPrint.prettyPrint(it, overloadPrinter());	1✔
243	}
244
245	private static TypePrettyPrinter overloadPrinter() {
246	return new TypePrettyPrinter().qualifyNames(false).printMethodResult(false);	1✔
247	}
248
249
250	public static CharSequence prettyPrint(JavaNode node) {
251	StringBuilder sb = new StringBuilder();	1✔
252	node.acceptVisitor(new ExprPrinter(), sb);	1✔
253	return sb;	1✔
254	}
255
256	static class ExprPrinter extends JavaVisitorBase<StringBuilder, Void> {	1✔
257
258	private static final int MAX_ARG_LENGTH = 20;
259
260	@Override
261	public Void visitJavaNode(JavaNode node, StringBuilder data) {
UNCOV 262	data.append("<<NOT_IMPLEMENTED: ").append(node).append(">>");	×
UNCOV 263	return null; // don't recurse	×
264	}
265
266	@Override
267	public Void visit(ASTTypeExpression node, StringBuilder data) {
268	node.getTypeNode().acceptVisitor(this, data);	1✔
269	return null;	1✔
270	}
271
272	@Override
273	public Void visit(ASTCastExpression node, StringBuilder data) {
274	ppInParens(data, node.getCastType()).append(' ');	1✔
275	node.getOperand().acceptVisitor(this, data);	1✔
276	return null;	1✔
277	}
278
279	@Override
280	public Void visit(ASTClassLiteral node, StringBuilder data) {
281	node.getTypeNode().acceptVisitor(this, data);	1✔
282	data.append(".class");	1✔
283	return null;	1✔
284	}
285
286	@Override
287	public Void visitLiteral(ASTLiteral node, StringBuilder data) {
288	data.append(node.getText());	1✔
289	return null;	1✔
290	}
291
292	@Override
293	public Void visit(ASTFieldAccess node, StringBuilder data) {
294	addQualifier(node, data);	1✔
295	data.append(node.getName());	1✔
296	return null;	1✔
297	}
298
299	@Override
300	public Void visit(ASTVariableAccess node, StringBuilder data) {
301	data.append(node.getName());	1✔
302	return null;	1✔
303	}
304
305	@Override
306	public Void visit(ASTThisExpression node, StringBuilder data) {
307	if (node.getQualifier() != null) {	1✔
308	node.getQualifier().acceptVisitor(this, data);	1✔
309	data.append('.');	1✔
310	}
311	data.append("this");	1✔
312	return null;	1✔
313	}
314
315	@Override
316	public Void visit(ASTSuperExpression node, StringBuilder data) {
317	if (node.getQualifier() != null) {	×
318	node.getQualifier().acceptVisitor(this, data);	×
319	data.append('.');	×
320	}
321	data.append("super");	×
322	return null;	×
323	}
324
325	@Override
326	public Void visit(ASTArrayAccess node, StringBuilder data) {
327	node.getQualifier().acceptVisitor(this, data);	×
328	data.append('[');	×
329	node.getIndexExpression().acceptVisitor(this, data);	×
330	data.append(']');	×
331	return null;	×
332	}
333
334	@Override
335	public Void visitType(ASTType node, StringBuilder data) {
336	prettyPrintTypeNode(data, node);	1✔
337	return null;	1✔
338	}
339
340	@Override
341	public Void visit(ASTAmbiguousName node, StringBuilder data) {
342	data.append(node.getName());	1✔
343	return null;	1✔
344	}
345
346	@Override
347	public Void visit(ASTInfixExpression node, StringBuilder sb) {
348	printWithParensIfNecessary(node.getLeftOperand(), sb, node);	1✔
349	sb.append(' ');	1✔
350	sb.append(node.getOperator());	1✔
351	sb.append(' ');	1✔
352	printWithParensIfNecessary(node.getRightOperand(), sb, node);	1✔
353	return null;	1✔
354	}
355
356
357	@Override
358	public Void visit(ASTUnaryExpression node, StringBuilder sb) {
359	sb.append(node.getOperator());	1✔
360	printWithParensIfNecessary(node.getOperand(), sb, node);	1✔
361	return null;	1✔
362	}
363
364	private void printWithParensIfNecessary(ASTExpression operand, StringBuilder sb, ASTExpression parent) {
365	if (operand.isParenthesized() && needsParentheses(operand, parent) != Necessity.NEVER) {	1✔
366	ppInParens(sb, operand);	1✔
367	} else {
368	operand.acceptVisitor(this, sb);	1✔
369	}
370	}	1✔
371
372	@Override
373	public Void visit(ASTConditionalExpression node, StringBuilder sb) {
374	printWithParensIfNecessary(node.getCondition(), sb, node);	1✔
375	sb.append(" ? ");	1✔
376	printWithParensIfNecessary(node.getThenBranch(), sb, node);	1✔
377	sb.append(" : ");	1✔
378	printWithParensIfNecessary(node.getElseBranch(), sb, node);	1✔
379	return null;	1✔
380	}
381
382	@Override
383	public Void visit(ASTLambdaExpression node, StringBuilder sb) {
384	node.getParameters().acceptVisitor(this, sb);	1✔
385	sb.append(" -> ");	1✔
386	ASTExpression exprBody = node.getExpression();	1✔
387	if (exprBody != null) {	1✔
388	exprBody.acceptVisitor(this, sb);	1✔
389	} else {
390	sb.append("{ ... }");	1✔
391	}
392	return null;	1✔
393	}
394
395	@Override
396	public Void visit(ASTLambdaParameterList node, StringBuilder sb) {
397	if (node.size() == 1) {	1✔
398	sb.append(node.get(0).getVarId().getName());	1✔
399	return null;	1✔
400	} else if (node.isEmpty()) {	1✔
401	sb.append("()");	1✔
402	return null;	1✔
403	}
404
405	sb.append('(');	1✔
406	sb.append(node.get(0).getVarId().getName());	1✔
407	node.toStream().drop(1).forEach(it -> {	1✔
408	sb.append(", ");	1✔
409	sb.append(it.getVarId().getName());	1✔
410	});	1✔
411	sb.append(')');	1✔
412
413	return null;	1✔
414	}
415
416	@Override
417	public Void visit(ASTMethodCall node, StringBuilder sb) {
418	addQualifier(node, sb);	1✔
419	ppTypeArgs(sb, node.getExplicitTypeArguments());	1✔
420	sb.append(node.getMethodName());	1✔
421	ppArguments(sb, node.getArguments());	1✔
422	return null;	1✔
423	}
424
425	@Override
426	public Void visit(ASTConstructorCall node, StringBuilder sb) {
427	addQualifier(node, sb);	1✔
428	sb.append("new ");	1✔
429	ppTypeArgs(sb, node.getExplicitTypeArguments());	1✔
430	prettyPrintTypeNode(sb, node.getTypeNode());	1✔
431	ppArguments(sb, node.getArguments());	1✔
432	return null;	1✔
433	}
434
435	private void ppArguments(StringBuilder sb, ASTArgumentList arguments) {
436	if (arguments.isEmpty()) {	1✔
437	sb.append("()");	1✔
438	} else {
439	final int argStart = sb.length();	1✔
440	sb.append('(');	1✔
441	boolean first = true;	1✔
442	for (ASTExpression arg : arguments) {	1✔
443	if (sb.length() - argStart >= MAX_ARG_LENGTH) {	1✔
444	sb.append("...");	1✔
445	break;	1✔
446	} else if (!first) {	1✔
447	sb.append(", ");	1✔
448	}
449	arg.acceptVisitor(this, sb);	1✔
450	first = false;	1✔
451	}	1✔
452	sb.append(')');	1✔
453	}
454	}	1✔
455
456	@Override
457	public Void visit(ASTMethodReference node, StringBuilder sb) {
458	printWithParensIfNecessary(node.getQualifier(), sb, node);	1✔
459	sb.append("::");	1✔
460	ppTypeArgs(sb, node.getExplicitTypeArguments());	1✔
461	sb.append(node.getMethodName());	1✔
462	return null;	1✔
463	}
464
465	private void addQualifier(QualifiableExpression node, StringBuilder data) {
466	ASTExpression qualifier = node.getQualifier();	1✔
467	if (qualifier != null) {	1✔
468	printWithParensIfNecessary(qualifier, data, node);	1✔
469	data.append('.');	1✔
470	}
471
472	}	1✔
473
474	private StringBuilder ppInParens(StringBuilder data, JavaNode qualifier) {
475	data.append('(');	1✔
476	qualifier.acceptVisitor(this, data);	1✔
477	return data.append(')');	1✔
478	}
479
480
481	private void ppTypeArgs(StringBuilder data, @Nullable ASTTypeArguments targs) {
482	if (targs == null) {	1✔
483	return;	1✔
484	}
485	data.append('<');	1✔
486	prettyPrintTypeNode(data, targs.get(0));	1✔
487	for (int i = 1; i < targs.size(); i++) {	1!
488	data.append(", ");	×
489	prettyPrintTypeNode(data, targs.get(i));	×
490	}
491	data.append('>');	1✔
492	}	1✔
493
494	}
495
496
497	}

pmd / pmd / #3996

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous