From 6ffee881103008c7da798a33471dca1886b17ba1 Mon Sep 17 00:00:00 2001 From: Martin Monperrus Date: Mon, 7 Nov 2016 11:31:05 +0100 Subject: [PATCH] refactor: removes duplicated code --- .../reflect/declaration/CtElementImpl.java | 7 +- .../visitor/ShortRepresentationPrinter.java | 719 ------------------ 2 files changed, 3 insertions(+), 723 deletions(-) delete mode 100644 src/main/java/spoon/support/visitor/ShortRepresentationPrinter.java diff --git a/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java b/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java index 330c944740d..1c668170c1b 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java @@ -17,7 +17,6 @@ package spoon.support.reflect.declaration; import org.apache.log4j.Logger; - import spoon.reflect.code.CtComment; import spoon.reflect.cu.SourcePosition; import spoon.reflect.declaration.CtAnnotation; @@ -37,8 +36,8 @@ import spoon.support.reflect.cu.SourcePositionImpl; import spoon.support.util.EmptyClearableList; import spoon.support.util.EmptyClearableSet; +import spoon.support.visitor.DeepRepresentationVisitor; import spoon.support.visitor.HashcodeVisitor; -import spoon.support.visitor.ShortRepresentationPrinter; import spoon.support.visitor.TypeReferenceScanner; import spoon.support.visitor.equals.CloneHelper; import spoon.support.visitor.equals.EqualsVisitor; @@ -98,9 +97,9 @@ public CtElementImpl() { @Override public String getShortRepresentation() { - final ShortRepresentationPrinter printer = new ShortRepresentationPrinter(); + final DeepRepresentationVisitor printer = new DeepRepresentationVisitor(); printer.scan(this); - return printer.getShortRepresentation(); + return printer.toString(); } diff --git a/src/main/java/spoon/support/visitor/ShortRepresentationPrinter.java b/src/main/java/spoon/support/visitor/ShortRepresentationPrinter.java deleted file mode 100644 index f0417ecc674..00000000000 --- a/src/main/java/spoon/support/visitor/ShortRepresentationPrinter.java +++ /dev/null @@ -1,719 +0,0 @@ -/** - * Copyright (C) 2006-2016 INRIA and contributors - * Spoon - http://spoon.gforge.inria.fr/ - * - * This software is governed by the CeCILL-C License under French law and - * abiding by the rules of distribution of free software. You can use, modify - * and/or redistribute the software under the terms of the CeCILL-C license as - * circulated by CEA, CNRS and INRIA at http://www.cecill.info. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL-C License for more details. - * - * The fact that you are presently reading this means that you have had - * knowledge of the CeCILL-C license and that you accept its terms. - */ -package spoon.support.visitor; - -import spoon.reflect.code.CtAnnotationFieldAccess; -import spoon.reflect.code.CtArrayAccess; -import spoon.reflect.code.CtArrayRead; -import spoon.reflect.code.CtArrayWrite; -import spoon.reflect.code.CtAssert; -import spoon.reflect.code.CtAssignment; -import spoon.reflect.code.CtBinaryOperator; -import spoon.reflect.code.CtBlock; -import spoon.reflect.code.CtBreak; -import spoon.reflect.code.CtCase; -import spoon.reflect.code.CtCatch; -import spoon.reflect.code.CtCatchVariable; -import spoon.reflect.code.CtCodeSnippetExpression; -import spoon.reflect.code.CtCodeSnippetStatement; -import spoon.reflect.code.CtComment; -import spoon.reflect.code.CtConditional; -import spoon.reflect.code.CtConstructorCall; -import spoon.reflect.code.CtContinue; -import spoon.reflect.code.CtDo; -import spoon.reflect.code.CtExecutableReferenceExpression; -import spoon.reflect.code.CtExpression; -import spoon.reflect.code.CtFieldRead; -import spoon.reflect.code.CtFieldWrite; -import spoon.reflect.code.CtFor; -import spoon.reflect.code.CtForEach; -import spoon.reflect.code.CtIf; -import spoon.reflect.code.CtInvocation; -import spoon.reflect.code.CtLambda; -import spoon.reflect.code.CtLiteral; -import spoon.reflect.code.CtLocalVariable; -import spoon.reflect.code.CtNewArray; -import spoon.reflect.code.CtNewClass; -import spoon.reflect.code.CtOperatorAssignment; -import spoon.reflect.code.CtReturn; -import spoon.reflect.code.CtStatement; -import spoon.reflect.code.CtStatementList; -import spoon.reflect.code.CtSuperAccess; -import spoon.reflect.code.CtSwitch; -import spoon.reflect.code.CtSynchronized; -import spoon.reflect.code.CtThisAccess; -import spoon.reflect.code.CtThrow; -import spoon.reflect.code.CtTry; -import spoon.reflect.code.CtTryWithResource; -import spoon.reflect.code.CtTypeAccess; -import spoon.reflect.code.CtUnaryOperator; -import spoon.reflect.code.CtVariableRead; -import spoon.reflect.code.CtVariableWrite; -import spoon.reflect.code.CtWhile; -import spoon.reflect.declaration.CtAnnotation; -import spoon.reflect.declaration.CtAnnotationMethod; -import spoon.reflect.declaration.CtAnnotationType; -import spoon.reflect.declaration.CtAnonymousExecutable; -import spoon.reflect.declaration.CtClass; -import spoon.reflect.declaration.CtConstructor; -import spoon.reflect.declaration.CtElement; -import spoon.reflect.declaration.CtEnum; -import spoon.reflect.declaration.CtEnumValue; -import spoon.reflect.declaration.CtExecutable; -import spoon.reflect.declaration.CtField; -import spoon.reflect.declaration.CtInterface; -import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtPackage; -import spoon.reflect.declaration.CtParameter; -import spoon.reflect.declaration.CtTypeParameter; -import spoon.reflect.reference.CtArrayTypeReference; -import spoon.reflect.reference.CtCatchVariableReference; -import spoon.reflect.reference.CtExecutableReference; -import spoon.reflect.reference.CtFieldReference; -import spoon.reflect.reference.CtIntersectionTypeReference; -import spoon.reflect.reference.CtLocalVariableReference; -import spoon.reflect.reference.CtPackageReference; -import spoon.reflect.reference.CtParameterReference; -import spoon.reflect.reference.CtTypeParameterReference; -import spoon.reflect.reference.CtTypeReference; -import spoon.reflect.reference.CtUnboundVariableReference; -import spoon.reflect.reference.CtWildcardReference; -import spoon.reflect.visitor.CtVisitor; - -import java.lang.annotation.Annotation; -import java.util.List; - -public class ShortRepresentationPrinter implements CtVisitor { - private StringBuffer signature; - - public ShortRepresentationPrinter() { - super(); - reset(); - } - - public String getShortRepresentation() { - return signature.toString(); - } - - public void reset() { - signature = new StringBuffer(); - } - - public void scan(CtElement e) { - if (e != null) { - e.accept(this); - } - } - - protected ShortRepresentationPrinter write(String value) { - signature.append(value); - return this; - } - - private ShortRepresentationPrinter clearLast() { - signature.deleteCharAt(signature.length() - 1); - return this; - } - - @Override - public void visitCtAnnotation(CtAnnotation annotation) { - write("@"); - if (annotation.getAnnotationType() != null) { - write(annotation.getAnnotationType().getQualifiedName()); - } - } - - @Override - public void visitCtAnnotationType(CtAnnotationType annotationType) { - write("@interface ").write(annotationType.getQualifiedName()); - } - - @Override - public void visitCtAnonymousExecutable(CtAnonymousExecutable e) { - scan(e.getBody()); - } - - @Override - public void visitCtArrayRead(CtArrayRead arrayRead) { - printCtArrayAccess(arrayRead); - } - - @Override - public void visitCtArrayWrite(CtArrayWrite arrayWrite) { - printCtArrayAccess(arrayWrite); - } - - private > void printCtArrayAccess(CtArrayAccess arrayAccess) { - scan(arrayAccess.getTarget()); - write("["); - scan(arrayAccess.getIndexExpression()); - write("]"); - } - - @Override - public void visitCtArrayTypeReference(CtArrayTypeReference reference) { - scan(reference.getComponentType()); - write("[]"); - } - - @Override - public void visitCtAssert(CtAssert asserted) { - write("assert "); - scan(asserted.getAssertExpression()); - write(":"); - scan(asserted.getExpression()); - } - - @Override - public void visitCtAssignment(CtAssignment assignement) { - for (CtTypeReference ref : assignement.getTypeCasts()) { - write("("); - scan(ref); - write(")"); - } - write("("); - scan(assignement.getAssigned()); - write(" = "); - scan(assignement.getAssignment()); - write(")"); - } - - @Override - public void visitCtBinaryOperator(CtBinaryOperator operator) { - scan(operator.getLeftHandOperand()); - write(operator.getKind().toString()); - scan(operator.getRightHandOperand()); - } - - @Override - public void visitCtBlock(CtBlock block) { - write("{\n"); - for (CtStatement s : block.getStatements()) { - scan(s); - write(";\n"); - } - write("}"); - } - - @Override - public void visitCtBreak(CtBreak breakStatement) { - write("break "); - if (breakStatement.getTargetLabel() != null) { - write(breakStatement.getTargetLabel()); - } - } - - @Override - public void visitCtCase(CtCase caseStatement) { - write("case ("); - scan(caseStatement.getCaseExpression()); - for (CtStatement statement : caseStatement.getStatements()) { - scan(statement); - } - write(")"); - } - - @Override - public void visitCtCatch(CtCatch catchBlock) { - write("catch ("); - scan(catchBlock.getParameter().getType()); - write(")"); - } - - @Override - public void visitCtClass(CtClass ctClass) { - write("class ").write(ctClass.getQualifiedName()); - } - - @Override - public void visitCtTypeParameter(CtTypeParameter typeParameter) { - write(typeParameter.getSimpleName()); - } - - @Override - public void visitCtConditional(CtConditional conditional) { - scan(conditional.getCondition()); - write("?"); - scan(conditional.getThenExpression()); - write(":"); - scan(conditional.getElseExpression()); - } - - @Override - public void visitCtConstructor(CtConstructor c) { - write(c.getDeclaringType().getQualifiedName()); - write("("); - for (CtParameter p : c.getParameters()) { - scan(p.getType()); - write(","); - } - if (!c.getParameters().isEmpty()) { - clearLast(); - } - write(")"); - } - - @Override - public void visitCtContinue(CtContinue continueStatement) { - write("continue "); - scan(continueStatement.getLabelledStatement()); - } - - @Override - public void visitCtDo(CtDo doLoop) { - write("do "); - scan(doLoop.getBody()); - write(" while ("); - scan(doLoop.getLoopingExpression()); - write(")"); - } - - @Override - public > void visitCtEnum(CtEnum ctEnum) { - write("enum ").write(ctEnum.getQualifiedName()); - } - - @Override - public void visitCtExecutableReference(CtExecutableReference reference) { - scan(reference.getDeclaringType()); - - write(CtExecutable.EXECUTABLE_SEPARATOR); - if (reference.isConstructor()) { - write(reference.getDeclaringType().getSimpleName()); - } else { - write(reference.getSimpleName()); - } - write("("); - if (reference.getParameters().size() > 0) { - for (CtTypeReference param : reference.getParameters()) { - if (param != null && !"null".equals(param.getSimpleName())) { - scan(param); - } else { - write(CtExecutableReference.UNKNOWN_TYPE); - } - write(", "); - } - clearLast(); - clearLast(); - } - write(")"); - } - - @Override - public void visitCtField(CtField f) { - scan(f.getType()); - write(" ").write(f.getSimpleName()); - } - - @Override - public void visitCtEnumValue(CtEnumValue enumValue) { - visitCtField(enumValue); - } - - @Override - public void visitCtThisAccess(CtThisAccess thisAccess) { - write(thisAccess.getType().getQualifiedName() + ".this"); - } - - @Override - public void visitCtAnnotationFieldAccess(CtAnnotationFieldAccess annotationFieldAccess) { - scan(annotationFieldAccess.getTarget()); - } - - @Override - public void visitCtFieldReference(CtFieldReference reference) { - if (reference.getType() != null) { - write(reference.getType().getQualifiedName()); - } else { - write(""); - } - write(" "); - if (reference.getDeclaringType() != null) { - write(reference.getDeclaringType().getQualifiedName()); - write(CtField.FIELD_SEPARATOR); - } - write(reference.getSimpleName()); - } - - @Override - public void visitCtFor(CtFor forLoop) { - write("for ("); - for (CtStatement s : forLoop.getForInit()) { - scan(s); - write(","); - } - if (!forLoop.getForInit().isEmpty()) { - clearLast(); - } - write(";"); - scan(forLoop.getExpression()); - write(";"); - for (CtStatement s : forLoop.getForUpdate()) { - scan(s); - write(","); - } - if (!forLoop.getForUpdate().isEmpty()) { - clearLast(); - } - write(")"); - scan(forLoop.getBody()); - } - - @Override - public void visitCtForEach(CtForEach foreach) { - write("for ("); - scan(foreach.getVariable()); - write(":"); - scan(foreach.getExpression()); - write(")"); - scan(foreach.getBody()); - } - - @Override - public void visitCtIf(CtIf ifElement) { - write("if ("); - scan(ifElement.getCondition()); - write(") then "); - scan((CtStatement) ifElement.getThenStatement()); - write(" else "); - scan((CtStatement) ifElement.getElseStatement()); - } - - @Override - public void visitCtInterface(CtInterface intrface) { - write("interface "); - write(intrface.getQualifiedName()); - } - - @Override - public void visitCtInvocation(CtInvocation invocation) { - write("("); - scan(invocation.getExecutable()); - write("("); - for (int i = 0; i < invocation.getArguments().size(); i++) { - CtExpression arg_i = invocation.getArguments().get(i); - scan(arg_i); - if (i != (invocation.getArguments().size() - 1)) { - write(","); - } - } - write(")"); - write(")"); - } - - @Override - public void visitCtLiteral(CtLiteral literal) { - if (literal.getValue() != null) { - write(literal.toString()); - } else { - write("null"); - } - } - - @Override - public void visitCtLocalVariable(CtLocalVariable localVariable) { - write(localVariable.getSimpleName()); - } - - @Override - public void visitCtLocalVariableReference( - CtLocalVariableReference reference) { - write(reference.getType().getQualifiedName()).write(" "); - write(reference.getSimpleName()); - - } - - @Override - public void visitCtCatchVariable(CtCatchVariable catchVariable) { - write(catchVariable.getSimpleName()); - } - - @Override - public void visitCtCatchVariableReference(CtCatchVariableReference reference) { - scan(reference.getDeclaration()); - } - - @Override - public void visitCtMethod(CtMethod m) { - if (!m.getFormalCtTypeParameters().isEmpty()) { - scan(m.getFormalCtTypeParameters()); - write(" "); - } - scan(m.getType()); - write(" "); - write(m.getSimpleName()); - write("("); - for (CtParameter p : m.getParameters()) { - scan(p.getType()); - write(","); - } - if (!m.getParameters().isEmpty()) { - clearLast(); - } - write(")"); - } - - @Override - public void visitCtAnnotationMethod(CtAnnotationMethod annotationMethod) { - visitCtMethod(annotationMethod); - } - - private void scan(List formalTypeParameters) { - if (formalTypeParameters != null && formalTypeParameters.size() > 0) { - write("<"); - for (CtTypeParameter typeParameter : formalTypeParameters) { - scan(typeParameter); - write(","); - } - clearLast(); - write(">"); - } - } - - @Override - public void visitCtNewArray(CtNewArray newArray) { - write("new "); - scan(newArray.getType()); - for (CtExpression c : newArray.getDimensionExpressions()) { - write("["); - scan(c); - write("]"); - } - write("{"); - for (CtExpression e : newArray.getElements()) { - scan(e); - write(","); - } - if (!newArray.getElements().isEmpty()) { - clearLast(); - } - write("}"); - } - - @Override - public void visitCtConstructorCall(CtConstructorCall ctConstructorCall) { - write("new "); - scan(ctConstructorCall.getExecutable()); - } - - @Override - public void visitCtNewClass(CtNewClass newClass) { - write("new "); - scan(newClass.getExecutable()); - scan(newClass.getAnonymousClass()); - } - - @Override - public void visitCtLambda(CtLambda lambda) { - write("("); - scan(lambda.getType()); - write(") ("); - if (!lambda.getParameters().isEmpty()) { - for (CtParameter parameter : lambda.getParameters()) { - scan(parameter); - write(","); - } - clearLast(); - } - write(")"); - } - - @Override - public > void visitCtExecutableReferenceExpression( - CtExecutableReferenceExpression expression) { - write(expression.toString()); - } - - @Override - public void visitCtCodeSnippetExpression(CtCodeSnippetExpression expression) { - write(expression.getValue()); - } - - @Override - public void visitCtCodeSnippetStatement(CtCodeSnippetStatement statement) { - write(statement.getValue()); - } - - @Override - public void visitCtOperatorAssignment(CtOperatorAssignment assignment) { - scan(assignment.getAssigned()); - write(assignment.getKind().toString()); - scan(assignment.getAssignment()); - } - - @Override - public void visitCtPackage(CtPackage ctPackage) { - write(ctPackage.getQualifiedName()); - } - - @Override - public void visitCtPackageReference(CtPackageReference reference) { - write(reference.getSimpleName()); - } - - @Override - public void visitCtParameter(CtParameter parameter) { - write(parameter.getSimpleName()); - } - - @Override - public void visitCtParameterReference(CtParameterReference reference) { - write(reference.getType().getQualifiedName()).write(" "); - write(reference.getSimpleName()); - } - - @Override - public void visitCtReturn(CtReturn returnStatement) { - write("return "); - scan(returnStatement.getReturnedExpression()); - } - - @Override - public void visitCtStatementList(CtStatementList statements) { - for (CtStatement s : statements.getStatements()) { - scan(s); - write(";\n"); - } - } - - @Override - public void visitCtSwitch(CtSwitch switchStatement) { - write("switch("); - scan(switchStatement.getSelector()); - write(")"); - for (CtCase c : switchStatement.getCases()) { - scan(c); - } - } - - @Override - public void visitCtSynchronized(CtSynchronized synchro) { - write("synchronized ("); - scan(synchro.getExpression()); - write(") "); - scan(synchro.getBlock()); - } - - @Override - public void visitCtThrow(CtThrow throwStatement) { - write("throw "); - scan(throwStatement.getThrownExpression()); - } - - @Override - public void visitCtTry(CtTry tryBlock) { - write("try {\n"); - scan(tryBlock.getBody()); - for (CtCatch c : tryBlock.getCatchers()) { - scan(c); - } - scan(tryBlock.getFinalizer()); - } - - @Override - public void visitCtTryWithResource(CtTryWithResource tryWithResource) { - write("try ("); - for (CtLocalVariable resource : tryWithResource.getResources()) { - scan(resource); - } - write(") {\n"); - scan(tryWithResource.getBody()); - for (CtCatch c : tryWithResource.getCatchers()) { - scan(c); - } - scan(tryWithResource.getFinalizer()); - } - - @Override - public void visitCtTypeParameterReference(CtTypeParameterReference ref) { - write(ref.getQualifiedName()); - scan(ref.getBoundingType()); - } - - @Override - public void visitCtWildcardReference(CtWildcardReference wildcardReference) { - visitCtTypeParameterReference(wildcardReference); - } - - @Override - public void visitCtIntersectionTypeReference(CtIntersectionTypeReference reference) { - for (CtTypeReference ctTypeReference : reference.getBounds()) { - scan(ctTypeReference); - write(","); - } - clearLast(); - } - - @Override - public void visitCtTypeReference(CtTypeReference reference) { - write(reference.getQualifiedName()); - } - - @Override - public void visitCtTypeAccess(CtTypeAccess typeAccess) { - scan(typeAccess.getAccessedType()); - } - - @Override - public void visitCtUnaryOperator(CtUnaryOperator operator) { - scan(operator.getOperand()); - write(operator.getKind().toString()); - } - - @Override - public void visitCtVariableRead(CtVariableRead variableRead) { - scan(variableRead.getVariable()); - } - - @Override - public void visitCtVariableWrite(CtVariableWrite variableWrite) { - scan(variableWrite.getVariable()); - } - - @Override - public void visitCtWhile(CtWhile whileLoop) { - write("while ("); - scan(whileLoop.getLoopingExpression()); - write(")"); - scan(whileLoop.getBody()); - } - - @Override - public void visitCtUnboundVariableReference(CtUnboundVariableReference reference) { - write(reference.getSimpleName()); - } - - @Override - public void visitCtFieldRead(CtFieldRead fieldRead) { - scan(fieldRead.getVariable()); - } - - @Override - public void visitCtFieldWrite(CtFieldWrite fieldWrite) { - scan(fieldWrite.getVariable()); - } - - @Override - public void visitCtSuperAccess(CtSuperAccess f) { - write(f.getType().getQualifiedName() + ".super"); - } - - @Override - public void visitCtComment(CtComment comment) { - write(comment.getContent()); - } -}