Create rule S8132: String conversions should use explicit methods instead of empty string concatenation (#5665)

* Create rule S8132

* Update rules/S8132/apex/rule.adoc in PR #5665

* Update rules/S8132/apex/metadata.json in PR #5665

* Update metadata and description

---------

Co-authored-by: denis-troller <[email protected]>
Co-authored-by: denis-troller <[email protected]>
Co-authored-by: yassin-kammoun-sonarsouce <[email protected]>

Author: 3 people

rules/S8132/apex/metadata.json

@@ -0,0 +1,27 @@
+{
+  "title": "String conversions should use explicit methods instead of empty string concatenation",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant/Issue",
+    "constantCost": "5 min"
+  },
+  "tags": [
+    "performance",
+    "readability"
+  ],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-8132",
+  "sqKey": "S8132",
+  "scope": "Main",
+  "defaultQualityProfiles": [
+    "Sonar way"
+  ],
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CLEAR"
+  }
+}

rules/S8132/apex/rule.adoc

@@ -0,0 +1,66 @@
+This rule raises an issue when values are converted to strings by concatenating them with empty strings (``++''++``).
+
+== Why is this an issue?
+
+Converting values to strings by concatenating them with empty strings is an inefficient and unclear practice.
+
+When you write ``++'' + someValue++``, the Apex runtime must:
+
+* Create a temporary string object for the empty string
+* Convert ``++someValue++`` to its string representation
+* Concatenate these two strings
+* Return the result
+
+This process involves unnecessary object creation and string manipulation overhead.
+
+Using explicit ``++toString()++`` methods is more efficient because:
+
+* It directly converts the value to a string without intermediate steps
+* The intent is clearer to other developers reading your code
+* It follows Apex best practices for type conversion
+
+The performance difference becomes more noticeable when this pattern is used frequently, such as in loops or bulk operations common in Salesforce development.
+
+=== What is the potential impact?
+
+This issue impacts code performance and maintainability:
+
+* *Performance degradation*: Unnecessary object creation and string operations can slow down your code, especially in bulk operations
+* *Reduced readability*: The intent to convert a value to string is less clear when using concatenation
+* *Maintenance overhead*: Code reviewers and future developers may not immediately understand the purpose of empty string concatenation
+
+== How to fix it
+
+Replace empty string concatenation with the appropriate ``++toString()++`` method for the data type or use ``++String.valueOf()++``.
+
+=== Code examples
+
+==== Noncompliant code example
+
+[source,apex,diff-id=1,diff-type=noncompliant]
+----
+String numberAsString = '' + 123; // Noncompliant
+String decimalAsString = '' + 45.67; // Noncompliant
+String booleanAsString = '' + true; // Noncompliant
+----
+
+==== Compliant solution
+
+[source,apex,diff-id=1,diff-type=compliant]
+----
+String numberAsString = String.valueOf(123);
+String decimalAsString = String.valueOf(45.67);
+String booleanAsString = String.valueOf(true);
+----
+
+== Resources
+
+=== Documentation
+
+ * Apex String Class - https://developer.salesforce.com/docs/atlas.en-us.apexref.meta/apexref/apex_methods_system_string.htm[Official Salesforce documentation for String class methods including valueOf()]
+
+ * Apex Data Types - https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/langCon_apex_primitives.htm[Documentation on Apex primitive data types and their conversion methods]
+
+=== Standards
+
+ * Salesforce Apex Best Practices - https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_best_practices.htm[Official Salesforce guidelines for writing efficient Apex code]

rules/S8132/metadata.json

@@ -0,0 +1,2 @@
+{
+}