New rule S2198: Silly mathematical comparisons should not be made

analyzers/rspec/cs/S2198_c#.html

@@ -0,0 +1,18 @@
+<p>Certain mathematical comparisons will always return the same value, and should simply not be made.</p>
+<p>This comparison will always return <code>false</code>:</p>
+<ul>
+  <li> comparing a <code>float</code> with a <code>double</code> constant that’s outside the <code>float</code> range </li>
+</ul>
+<p>These will always return <code>true</code>:</p>
+<ul>
+  <li> comparing <code>aByte &lt;= Byte.MaxValue</code> and <code>aByte &gt;= Byte.MinValue</code> </li>
+  <li> comparing <code>anInt &lt;= int.MaxValue</code> and <code>anInt &gt;= int.MinValue</code> </li>
+  <li> comparing <code>aLong &lt;= long.MaxValue</code> and <code>aLong &gt;= long.MinValue</code> </li>
+</ul>
+<h2>Noncompliant Code Example</h2>
+<pre>
+float f = 42.0f;
+const double d = float.MaxValue + 1;
+if (f &lt;= d) { } // Noncompliant
+</pre>
+

analyzers/rspec/cs/S2198_c#.json

@@ -0,0 +1,17 @@
+{
+  "title": "Silly mathematical comparisons should not be made",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "15min"
+  },
+  "tags": [
+    "suspicious"
+  ],
+  "defaultSeverity": "Critical",
+  "ruleSpecification": "RSPEC-2198",
+  "sqKey": "S2198",
+  "scope": "Main",
+  "quickfix": "unknown"
+}

analyzers/rspec/cs/Sonar_way_profile.json

@@ -66,6 +66,7 @@
     "S2184",
     "S2187",
     "S2190",
+    "S2198",
     "S2201",
     "S2219",
     "S2222",

analyzers/src/SonarAnalyzer.CSharp/Rules/SillyMathematicalComparison.cs

@@ -0,0 +1,108 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2023 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using SonarAnalyzer.Helpers;
+
+namespace SonarAnalyzer.Rules.CSharp
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public sealed class SillyMathematicalComparison : SonarDiagnosticAnalyzer
+    {
+        private const string DiagnosticId = "S2198";
+        private const string MessageFormat = "Comparison to integral constant is useless; the constant is outside the range of type '{0}'";
+
+        private static readonly DiagnosticDescriptor Rule = DescriptorFactory.Create(DiagnosticId, MessageFormat);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        protected override void Initialize(SonarAnalysisContext context) =>
+            context.RegisterNodeAction(
+                CheckBinary,
+                SyntaxKind.GreaterThanExpression,
+                SyntaxKind.GreaterThanOrEqualExpression,
+                SyntaxKind.LessThanExpression,
+                SyntaxKind.LessThanOrEqualExpression);
+
+        private static void CheckBinary(SonarSyntaxNodeReportingContext context)
+        {
+            var binary = (BinaryExpressionSyntax)context.Node;
+            var typeIdentifier = string.Empty;
+            if (ShouldRaise(context.SemanticModel, binary.Left, binary.Right, ref typeIdentifier))
+            {
+                context.ReportIssue(Diagnostic.Create(Rule, binary.GetLocation(), typeIdentifier));
+            }
+
+            if (ShouldRaise(context.SemanticModel, binary.Right, binary.Left, ref typeIdentifier))
+            {
+                context.ReportIssue(Diagnostic.Create(Rule, binary.GetLocation(), typeIdentifier));
+            }
+        }
+
+        private static bool ShouldRaise(SemanticModel model, SyntaxNode expectedConstant, SyntaxNode other, ref string typeIdentifier) =>
+            TryGetConstant(model, expectedConstant, out var constant)
+            && model.GetSymbolInfo(other).Symbol.GetSymbolType() is { } symbol
+            && TryGetRange(symbol, out typeIdentifier, out var min, out var max)
+            && (constant < min || constant > max);
+
+        private static bool TryGetConstant(SemanticModel model, SyntaxNode expectedConstant, out double constant)
+        {
+            if (FindConstant(model, expectedConstant, Convert.ToDouble) is { } constValue)
+            {
+                constant = constValue;
+                return true;
+            }
+
+            constant = default;
+            return false;
+        }
+
+        private static T? FindConstant<T>(SemanticModel semanticModel, SyntaxNode node, Func<object, T> converter) where T : struct
+            => semanticModel.GetSymbolInfo(node).Symbol is var symbol
+                && !IsFieldOrPropertyOutsideSystemNamespace(symbol)
+                && !IsEnum(symbol)
+                && CSharpFacade.Instance.FindConstantValue(semanticModel, node) is { } value
+                && ConversionHelper.TryConvertWith(value, converter, out T typedValue)
+                ? typedValue
+                : null;
+
+        private static bool TryGetRange(ITypeSymbol typeSymbol, out string typeIdentifier, out double min, out double max)
+        {
+            if (typeSymbol.Is(KnownType.System_Single))
+            {
+                typeIdentifier = "float";
+                min = float.MinValue;
+                max = float.MaxValue;
+                return true;
+            }
+
+            typeIdentifier = default;
+            min = default;
+            max = default;
+            return false;
+        }
+
+        private static bool IsFieldOrPropertyOutsideSystemNamespace(ISymbol symbol) =>
+            symbol is { Kind: SymbolKind.Field or SymbolKind.Property }
+            && symbol.ContainingNamespace.Name != nameof(System);
+
+        private static bool IsEnum(ISymbol symbol) =>
+            symbol.GetSymbolType() is INamedTypeSymbol { EnumUnderlyingType: { } };
+    }
+}

analyzers/tests/SonarAnalyzer.UnitTest/PackagingTests/RuleTypeMappingCS.cs

@@ -2122,7 +2122,7 @@ internal static class RuleTypeMappingCS
         // ["S2195"],
         // ["S2196"],
         ["S2197"] = "CODE_SMELL",
-        // ["S2198"],
+        ["S2198"] = "CODE_SMELL",
         // ["S2199"],
         // ["S2200"],
         ["S2201"] = "BUG",

analyzers/tests/SonarAnalyzer.UnitTest/Rules/SillyMathematicalComparison.cs

@@ -0,0 +1,34 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2023 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using CS = SonarAnalyzer.Rules.CSharp;
+
+namespace SonarAnalyzer.UnitTest.Rules
+{
+    [TestClass]
+    public class SillyMathematicalComparisonTest
+    {
+        private readonly VerifierBuilder builderCS = new VerifierBuilder<CS.SillyMathematicalComparison>();
+
+        [TestMethod]
+        public void SillyMathematicalComparison_CS() =>
+            builderCS.AddPaths("SillyMathematicalComparison.cs").Verify();
+    }
+}

analyzers/tests/SonarAnalyzer.UnitTest/TestCases/SillyMathematicalComparison.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SonarAnalyzer.UnitTest.TestCases
+{
+    internal class SillyMathematicalComparison
+    {
+        public void Floats()
+        {
+            float f = 42;
+
+            const double veryBig = double.MaxValue;
+            const double verySmall = double.MinValue;
+
+            _ = f < veryBig; // Noncompliant
+            _ = veryBig > f; // Noncompliant
+            _ = f > verySmall; // Noncompliant
+            _ = verySmall < f; // Noncompliant
+        }
+    }
+}