Merge branch 'main' into copilot/fix-207

Author: bcollamore

.editorconfig

@@ -112,6 +112,58 @@ dotnet_diagnostic.CS7035.severity = none
 # We do not need compile-time generated RegExs in Unit Tests. We'll prefer code readability.
 dotnet_diagnostic.SYSLIB1045.severity = none
 
+dotnet_diagnostic.MSTEST0001.severity = error
+dotnet_diagnostic.MSTEST0002.severity = error
+dotnet_diagnostic.MSTEST0003.severity = error
+dotnet_diagnostic.MSTEST0004.severity = error
+dotnet_diagnostic.MSTEST0005.severity = error
+dotnet_diagnostic.MSTEST0006.severity = error
+dotnet_diagnostic.MSTEST0007.severity = error
+dotnet_diagnostic.MSTEST0008.severity = error
+dotnet_diagnostic.MSTEST0009.severity = error
+dotnet_diagnostic.MSTEST0010.severity = error
+dotnet_diagnostic.MSTEST0011.severity = error
+dotnet_diagnostic.MSTEST0012.severity = error
+dotnet_diagnostic.MSTEST0013.severity = error
+dotnet_diagnostic.MSTEST0014.severity = error
+dotnet_diagnostic.MSTEST0015.severity = error
+dotnet_diagnostic.MSTEST0016.severity = error
+dotnet_diagnostic.MSTEST0017.severity = error
+dotnet_diagnostic.MSTEST0018.severity = error
+dotnet_diagnostic.MSTEST0019.severity = none	# Do not prefer TestInitialize over constructors
+dotnet_diagnostic.MSTEST0020.severity = error
+dotnet_diagnostic.MSTEST0021.severity = error
+dotnet_diagnostic.MSTEST0022.severity = error
+dotnet_diagnostic.MSTEST0023.severity = error
+dotnet_diagnostic.MSTEST0024.severity = error
+dotnet_diagnostic.MSTEST0025.severity = error
+dotnet_diagnostic.MSTEST0026.severity = error
+dotnet_diagnostic.MSTEST0027.severity = error
+dotnet_diagnostic.MSTEST0028.severity = error
+dotnet_diagnostic.MSTEST0029.severity = error
+dotnet_diagnostic.MSTEST0030.severity = error
+dotnet_diagnostic.MSTEST0031.severity = error
+dotnet_diagnostic.MSTEST0032.severity = error
+dotnet_diagnostic.MSTEST0033.severity = error
+dotnet_diagnostic.MSTEST0034.severity = error
+dotnet_diagnostic.MSTEST0035.severity = error
+dotnet_diagnostic.MSTEST0036.severity = error
+dotnet_diagnostic.MSTEST0037.severity = error
+dotnet_diagnostic.MSTEST0038.severity = error
+dotnet_diagnostic.MSTEST0039.severity = error
+dotnet_diagnostic.MSTEST0040.severity = error
+dotnet_diagnostic.MSTEST0041.severity = error
+dotnet_diagnostic.MSTEST0042.severity = error
+dotnet_diagnostic.MSTEST0043.severity = error
+dotnet_diagnostic.MSTEST0044.severity = error
+dotnet_diagnostic.MSTEST0045.severity = error
+dotnet_diagnostic.MSTEST0046.severity = error
+dotnet_diagnostic.MSTEST0047.severity = error
+dotnet_diagnostic.MSTEST0048.severity = error
+dotnet_diagnostic.MSTEST0049.severity = error
+dotnet_diagnostic.MSTEST0050.severity = error
+
+
 dotnet_diagnostic.IDE0001.severity = error
 dotnet_diagnostic.IDE0002.severity = error
 dotnet_diagnostic.IDE0003.severity = error

Documentation/Diagnostics/PH2033.md

@@ -0,0 +1,104 @@
+# PH2144: Backwards for-loop boundary check should use >= 0 instead of > 0
+
+| Property | Value  |
+|--|--|
+| Package | [Philips.CodeAnalysis.MaintainabilityAnalyzers](https://www.nuget.org/packages/Philips.CodeAnalysis.MaintainabilityAnalyzers) |
+| Diagnostic ID | PH2144 |
+| Category  | [Maintainability](../Maintainability.md) |
+| Analyzer | [AvoidIncorrectForLoopConditionAnalyzer](https://github.com/philips-software/roslyn-analyzers/blob/main/Philips.CodeAnalysis.MaintainabilityAnalyzers/Maintainability/AvoidIncorrectForLoopConditionAnalyzer.cs)
+| CodeFix  | Yes |
+| Severity | Error |
+| Enabled By Default | Yes |
+
+## Introduction
+
+When looping backwards from a collection count to 0, use `>= 0` instead of `> 0` to ensure the element at index 0 is processed. Using `> 0` in the loop condition causes the loop to skip the element at index 0, which is often unintended.
+
+## How to solve
+
+Change the loop condition from `> 0` to `>= 0` to include the element at index 0.
+
+## Example
+
+Code that triggers a diagnostic:
+``` cs
+class BadExample
+{
+    public void BadMethod()
+    {
+        var list = new List<int> { 1, 2, 3, 4, 5 };
+        
+        // This loop skips the element at index 0
+        for (var index = list.Count - 1; index > 0; index--)
+        {
+            Console.WriteLine(list[index]);
+        }
+    }
+}
+
+```
+
+And the replacement code:
+``` cs
+class GoodExample
+{
+    public void GoodMethod()
+    {
+        var list = new List<int> { 1, 2, 3, 4, 5 };
+        
+        // This loop processes all elements including index 0
+        for (var index = list.Count - 1; index >= 0; index--)
+        {
+            Console.WriteLine(list[index]);
+        }
+    }
+}
+
+```
+
+## Configuration
+
+This analyzer does not offer any special configuration. The general ways of [suppressing](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/suppress-warnings) diagnostics apply.
+
+## Legitimate Use Cases and Workarounds
+
+In rare cases, you may intentionally want to skip the element at index 0 in a backwards loop. When this is the case, the analyzer will produce a false positive. Here are several clean workarounds to avoid triggering the analyzer while preserving the intended behavior:
+
+### Workaround 1: Use `>= 1` instead of `> 0`
+``` cs
+// Instead of: for (var i = array.Length - 1; i > 0; i--)
+for (var i = array.Length - 1; i >= 1; i--)  // Mathematically equivalent but clearer intent
+{
+    // Process elements from index 1 to array.Length - 1 (skipping index 0)
+}
+```
+
+### Workaround 2: Make the exclusion explicit with variables
+``` cs
+// Make it clear that you're intentionally excluding the first element
+var startIndex = array.Length - 1;
+var stopBeforeIndex = 1;  // Stop before index 0, not including it
+for (var i = startIndex; i >= stopBeforeIndex; i--)
+{
+    // Process elements from index 1 to array.Length - 1 (skipping index 0)
+}
+```
+
+### Workaround 3: Use array slicing (C# 8.0+)
+``` cs
+// Process only the sub-array excluding the first element, then iterate normally
+var elementsToProcess = array[1..];  // Skip index 0
+for (var i = elementsToProcess.Length - 1; i >= 0; i--)
+{
+    // Process elements (original indices 1 to array.Length - 1)
+    DoSomething(elementsToProcess[i]);
+}
+```
+
+### Workaround 4: Use LINQ when appropriate
+``` cs
+// For simple operations, LINQ can be clearer
+array.Skip(1).Reverse().ToList().ForEach(element => DoSomething(element));
+```
+
+These workarounds make the intent clearer to both the analyzer and future maintainers of the code.

Documentation/Diagnostics/PH2035.md

@@ -0,0 +1,82 @@
+# PH2147: Avoid variables named exactly '_'
+
+| Property | Value  |
+|--|--|
+| Package | [Philips.CodeAnalysis.MaintainabilityAnalyzers](https://www.nuget.org/packages/Philips.CodeAnalysis.MaintainabilityAnalyzers) |
+| Diagnostic ID | PH2147 |
+| Category  | [Naming](../Naming.md) |
+| Analyzer | [AvoidVariableNamedUnderscoreAnalyzer](https://github.com/philips-software/roslyn-analyzers/blob/main/Philips.CodeAnalysis.MaintainabilityAnalyzers/Naming/AvoidVariableNamedUnderscoreAnalyzer.cs)
+| CodeFix  | No |
+| Severity | Error |
+| Enabled By Default | Yes |
+
+## Introduction
+
+This rule flags variables (local variables, foreach variables, for loop variables, using variables, and out parameters) that are named exactly `_` (single underscore).
+
+## Reason
+
+Variables named exactly `_` can be confused with C# discards. This can lead to unintended behavior where developers think they are using a discard but are actually creating a variable that captures the value.
+
+## How to fix violations
+
+Either use a proper discard (if you don't need the value) or use a more descriptive variable name (if you do need the value).
+
+## Examples
+
+### Incorrect
+
+```csharp
+// Local variable - looks like discard but is actually a variable
+byte[] _ = ExtractData(reader);
+
+// ForEach variable - confusing
+foreach (var _ in items)
+{
+    // code
+}
+
+// Out parameter - looks like discard
+if (int.TryParse(input, out int _))
+{
+    // code
+}
+```
+
+### Correct
+
+```csharp
+// Use a proper discard if you don't need the value
+_ = ExtractData(reader);
+
+// Or use a descriptive name if you do need the value
+byte[] data = ExtractData(reader);
+
+// ForEach with discard
+foreach (var _ in items)
+{
+    // Use discard syntax instead
+}
+
+// Out parameter with discard
+if (int.TryParse(input, out _))
+{
+    // code
+}
+
+// Or with a descriptive name
+if (int.TryParse(input, out int result))
+{
+    // code using result
+}
+```
+
+## Configuration
+
+This rule is enabled by default with Error severity.
+
+## Suppression
+
+```csharp
+[SuppressMessage("Philips.CodeAnalysis.MaintainabilityAnalyzers", "PH2147:Avoid variables named exactly '_'", Justification = "Reviewed.")]
+```