From dce07c6f35c76a3f8d769fd334ce32bd2a89d949 Mon Sep 17 00:00:00 2001
From: Sebastien Marichal <sebastien.marichal@sonarsource.com>
Date: Fri, 9 Aug 2024 16:46:04 +0200
Subject: [PATCH] Modify S4050: Promote C# rule to SonarWay (#4135)

---
 rules/S4050/csharp/metadata.json |   2 +-
 rules/S4050/csharp/rule.adoc     | 101 ++++++++++++++++---------------
 2 files changed, 52 insertions(+), 51 deletions(-)

diff --git a/rules/S4050/csharp/metadata.json b/rules/S4050/csharp/metadata.json
index 86c72367b3..a839d0d794 100644
--- a/rules/S4050/csharp/metadata.json
+++ b/rules/S4050/csharp/metadata.json
@@ -28,7 +28,7 @@
   "sqKey": "S4050",
   "scope": "All",
   "defaultQualityProfiles": [
-
+    "Sonar way"
   ],
   "quickfix": "unknown"
 }
diff --git a/rules/S4050/csharp/rule.adoc b/rules/S4050/csharp/rule.adoc
index d1fc5be6c6..3b115b4415 100644
--- a/rules/S4050/csharp/rule.adoc
+++ b/rules/S4050/csharp/rule.adoc
@@ -1,59 +1,54 @@
 == Why is this an issue?
 
-When implementing operator overloads, it is very important to make sure that all related operators and methods are consistent in their implementation.
+When overloading some arithmetic operator overloads, it is very important to make sure that all related operators and methods are consistent in their implementation.
 
 The following guidelines should be followed:
 
-* When providing ``++operator ==++`` you should also provide ``++operator !=++`` and vice-versa.
-* When providing ``++operator ==++`` you should also provide ``++Equals(Object)++`` and ``++GetHashCode()++``.
-* When providing ``++operator +, -, *, / or %++`` you should also provide ``++operator ==++``, respecting previous guidelines.
+* When providing `operator ==, !=` you should also provide `Equals(Object)` and `GetHashCode()`.
+* When providing `operator +, -, *, / or %` you should also provide `operator ==`, respecting the previous guideline.
 
-This rule raises an issue when any of these guidelines are not followed on publicly-visible type (public, protected or protected internal).
+This rule raises an issue when any of these guidelines are not followed on a publicly-visible class or struct (`public`, `protected` or `protected internal`).
 
+== How to fix it
 
-=== Noncompliant code example
+Make sure to implement all related operators.
 
-[source,csharp]
+=== Code examples
+
+==== Noncompliant code example
+
+[source,csharp,diff-id=1,diff-type=noncompliant]
 ----
-using System;
-
-namespace MyLibrary
+public class Foo // Noncompliant
 {
-  public class Foo // Noncompliant
-  {
     private int left;
     private int right;
 
     public Foo(int l, int r)
     {
-      this.left = l;
-      this.right = r;
+        this.left = l;
+        this.right = r;
     }
 
     public static Foo operator +(Foo a, Foo b)
     {
-      return new Foo(a.left + b.left, a.right + b.right);
+        return new Foo(a.left + b.left, a.right + b.right);
     }
 
     public static Foo operator -(Foo a, Foo b)
     {
-      return new Foo(a.left - b.left, a.right - b.right);
+        return new Foo(a.left - b.left, a.right - b.right);
     }
-  }
 }
 ----
 
 
-=== Compliant solution
+==== Compliant solution
 
-[source,csharp]
+[source,csharp,diff-id=1,diff-type=compliant]
 ----
-using System;
-
-namespace MyLibrary
+public class Foo
 {
-  public class Foo
-  {
     private int left;
     private int right;
 
@@ -63,42 +58,48 @@ namespace MyLibrary
       this.right = r;
     }
 
-    public static Foo operator +(Foo a, Foo b)
-    {
-      return new Foo(a.left + b.left, a.right + b.right);
-    }
-
-    public static Foo operator -(Foo a, Foo b)
-    {
-      return new Foo(a.left - b.left, a.right - b.right);
-    }
-
-    public static bool operator ==(Foo a, Foo b)
-    {
-      return (a.left == b.left && a.right == b.right);
-    }
-
-    public static bool operator !=(Foo a, Foo b)
-    {
-      return !(a == b);
-    }
-
     public override bool Equals(Object obj)
     {
-      Foo a = obj as Foo;
-      if (a == null)
-        return false;
-      return this == a;
+        var a = obj as Foo;
+        if (a == null)
+          return false;
+        return this == a;
     }
 
     public override int GetHashCode()
     {
-       return (this.left * 10) + this.right;
+        return HashCode.Combine(right, left);
+    }
+
+    public static Foo operator +(Foo a, Foo b)
+    {
+        return new Foo(a.left + b.left, a.right + b.right);
+    }
+
+    public static Foo operator -(Foo a, Foo b)
+    {
+        return new Foo(a.left - b.left, a.right - b.right);
+    }
+
+    public static bool operator ==(Foo a, Foo b)
+    {
+        return a.left == b.left && a.right == b.right;
+    }
+
+    public static bool operator !=(Foo a, Foo b)
+    {
+        return !(a == b);
     }
-  }
 }
 ----
 
+== Resources
+=== Documentation
+
+* Microsoft Learn - https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading[Operator overloading]
+* Microsoft Learn - https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/equality-operators[Equality operators]
+* Microsoft Learn - https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/arithmetic-operators[Arithmetic operators (C# reference)]
+
 ifdef::env-github,rspecator-view[]
 
 '''