feat: convert primitives to String with String.valueOf

code-transformation/src/main/java/xyz/keksdose/spoon/code_solver/TransformationEngine.java

@@ -29,6 +29,7 @@
 import xyz.keksdose.spoon.code_solver.transformations.qodana.ArraysToString;
 import xyz.keksdose.spoon.code_solver.transformations.qodana.EmptyStringCheck;
 import xyz.keksdose.spoon.code_solver.transformations.qodana.InnerClassStatic;
+import xyz.keksdose.spoon.code_solver.transformations.qodana.PrimitiveToString;
 import xyz.keksdose.spoon.code_solver.transformations.qodana.StaticAccess;
 import xyz.keksdose.spoon.code_solver.transformations.self.StringBuilderDirectUse;
 import xyz.keksdose.spoon.code_solver.transformations.self.ThreadLocalWithInitial;
@@ -46,7 +47,8 @@ public TransformationEngine() {
 		this.processors = List.of(StringBuilderDirectUse::new, ThreadLocalWithInitial::new,
 			TempoaryFolderAsParameter::new, EmptyStringCheck::new, ArraysToString::new,
 			Junit4AnnotationsTransformation::new, TestAnnotation::new, AssertionsTransformation::new,
-			AssertThatTransformation::new, ExpectedExceptionRemoval::new, StaticAccess::new, InnerClassStatic::new);
+			AssertThatTransformation::new, ExpectedExceptionRemoval::new, StaticAccess::new, InnerClassStatic::new,
+			PrimitiveToString::new);
 	}
 
 	public TransformationEngine setPrinting(IPrinting printing) {

code-transformation/src/main/java/xyz/keksdose/spoon/code_solver/transformations/qodana/PrimitiveToString.java

@@ -0,0 +1,74 @@
+
+package xyz.keksdose.spoon.code_solver.transformations.qodana;
+
+import spoon.reflect.code.BinaryOperatorKind;
+import spoon.reflect.code.CtBinaryOperator;
+import spoon.reflect.code.CtExpression;
+import spoon.reflect.code.CtInvocation;
+import spoon.reflect.declaration.CtType;
+import spoon.reflect.reference.CtExecutableReference;
+import spoon.reflect.reference.CtTypeReference;
+import xyz.keksdose.spoon.code_solver.history.Change;
+import xyz.keksdose.spoon.code_solver.history.ChangeListener;
+import xyz.keksdose.spoon.code_solver.history.MarkdownString;
+import xyz.keksdose.spoon.code_solver.transformations.BadSmell;
+import xyz.keksdose.spoon.code_solver.transformations.TransformationProcessor;
+
+public class PrimitiveToString extends TransformationProcessor<CtBinaryOperator<?>> {
+
+	private static final BadSmell STRING_VALUE_OF = new BadSmell() {
+		@Override
+		public MarkdownString getName() {
+			return MarkdownString.fromRaw("String-ValueOf-Primitive");
+		}
+
+		@Override
+		public MarkdownString getDescription() {
+			String raw = "Primitive types are converted to String using concationation with `\"\"`"
+					+ "String.valueOf(primitive) is the preferred way to convert a primitive to a String.";
+			String markdown = "Primitive types are converted to String using concationation with `\"\"`"
+					+ "`String.valueOf(primitive)` is the preferred way to convert a primitive to a String.";
+			return MarkdownString.fromMarkdown(raw, markdown);
+		}
+	};
+	public PrimitiveToString(ChangeListener listener) {
+		super(listener);
+	}
+
+	@Override
+	public void process(CtBinaryOperator<?> op) {
+		if (op.getKind().equals(BinaryOperatorKind.PLUS)) {
+			if (isEmptyString(op.getLeftHandOperand()) && isPrimitive(op.getRightHandOperand())) {
+				refactor(op, op.getRightHandOperand());
+			}
+			if (isPrimitive(op.getLeftHandOperand()) && isEmptyString(op.getRightHandOperand())) {
+				refactor(op, op.getLeftHandOperand());
+			}
+		}
+	}
+
+	private boolean isEmptyString(CtExpression<?> exp) {
+		return exp.toString().equals("\"\"");
+	}
+
+	private boolean isPrimitive(CtExpression<?> exp) {
+		return exp.getType() != null && exp.getType().isPrimitive();
+	}
+
+	private void refactor(CtBinaryOperator<?> op, CtExpression<?> primitive) {
+		CtTypeReference<Object> stringType = getFactory().Type().createSimplyQualifiedReference("java.lang.String");
+		CtExecutableReference<?> valueOf = getFactory().Executable()
+				.createReference(stringType, stringType, "valueOf", primitive.getType());
+		CtInvocation<?> valueOfInvocation = getFactory().Code()
+				.createInvocation(getFactory().createTypeAccess(stringType), valueOf, primitive);
+		notifyChangeListener(op, valueOfInvocation);
+		op.replace(valueOfInvocation);
+	}
+
+	private void notifyChangeListener(CtBinaryOperator<?> op, CtExpression<?> primitive) {
+		String raw = "Replaced " + op + " with String.valueOf(" + primitive + ")";
+		String markdown = "Replaced `" + op + "` with `String.valueOf(" + primitive + ")`";
+		CtType<?> parent = op.getParent(CtType.class).getTopLevelType();
+		setChanged(parent, new Change(STRING_VALUE_OF, MarkdownString.fromMarkdown(raw, markdown), parent));
+	}
+}