Create rule S8313: Compound assignment operators should be used for counter increments

rules/S8313/groovy/metadata.json

@@ -0,0 +1,27 @@
+{
+  "title": "Compound assignment operators should be used for counter increments",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant/Issue",
+    "constantCost": "2 min"
+  },
+  "tags": [
+    "convention",
+    "readability"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-8313",
+  "sqKey": "S8313",
+  "scope": "All",
+  "defaultQualityProfiles": [
+    "Sonar way"
+  ],
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "HIGH"
+    },
+    "attribute": "CONVENTIONAL"
+  }
+}

rules/S8313/groovy/rule.adoc

@@ -0,0 +1,51 @@
+This rule raises an issue when a variable is assigned the result of adding a value to itself, instead of using the compound assignment operator.
+
+== Why is this an issue?
+
+Using explicit assignment with addition (like `counter = counter + 1`) instead of compound assignment operators (like `counter += 1`) makes code more verbose and harder to read.
+
+Compound assignment operators are a standard feature in most programming languages, including Groovy. They provide a concise way to perform an operation on a variable and assign the result back to the same variable.
+
+The verbose form requires developers to:
+
+* Read the variable name twice
+* Mentally verify that both instances refer to the same variable
+* Process more text to understand a simple increment operation
+
+This pattern becomes particularly problematic when:
+
+* The variable name is long, making the line harder to scan
+* Multiple similar operations appear in the same code block
+* The code is reviewed or maintained by different developers
+
+Using compound assignment operators follows established coding conventions and makes the intent clearer - you're modifying the existing value rather than calculating a new one.
+
+=== What is the potential impact?
+
+This issue affects code readability and maintainability. While it doesn't introduce bugs or security vulnerabilities, it makes code unnecessarily verbose and harder to understand, especially for developers who need to quickly scan through the code.
+
+== How to fix it
+
+Replace the explicit assignment with addition using the compound assignment operator `+=`. This makes the code more concise and clearly expresses the intent to increment the variable.
+
+=== Code examples
+
+==== Noncompliant code example
+
+[source,groovy,diff-id=1,diff-type=noncompliant]
+----
+session.counter = session.counter + 1 // Noncompliant
+----
+
+==== Compliant solution
+
+[source,groovy,diff-id=1,diff-type=compliant]
+----
+session.counter += 1
+----
+
+== Resources
+
+=== Documentation
+
+ * Groovy Operators - https://groovy-lang.org/operators.html[Official Groovy documentation covering all operators including compound assignment operators]

rules/S8313/metadata.json

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