Mask comments and literals in rule 38 and the parameters panel (#579)

Review of #582 found rule 38 still matched MAXDOP 2 against the raw text,
so a MAXDOP 2 mentioned in a comment suppressed the Standard Edition DOP
warning. The app's parameters panel had the same raw OPTIMIZE FOR UNKNOWN
check for its annotation. Both now use MaskCommentsAndLiterals, which is
internal so the app can call it. Add direct tests for the helper.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01G625JBNh45iTR1hpT4CxNR

Author: erikdarlingdata

src/PlanViewer.App/Controls/PlanViewerControl.Parameters.cs

@@ -131,9 +131,11 @@ private void ShowParameters(PlanStatement statement)
         // Annotations
         if (allCompiledNull && parameters.Count > 0)
         {
+            // #579: the phrase inside a string literal or a comment is not a hint.
             var hasOptimizeForUnknown = statement.StatementText
                 .Contains("OPTIMIZE", StringComparison.OrdinalIgnoreCase)
-                && Regex.IsMatch(statement.StatementText, @"OPTIMIZE\s+FOR\s+UNKNOWN", RegexOptions.IgnoreCase);
+                && Regex.IsMatch(PlanAnalyzer.MaskCommentsAndLiterals(statement.StatementText),
+                    @"OPTIMIZE\s+FOR\s+UNKNOWN", RegexOptions.IgnoreCase);
 
             if (hasOptimizeForUnknown)
             {

src/PlanViewer.Core/Services/PlanAnalyzer.Helpers.cs

@@ -281,15 +281,15 @@ private static string FormatNodeRef(PlanNode node)
         return $"{node.PhysicalOp} (Node {node.NodeId})";
     }
 
-    /* #579: the rules that look for a hint or a keyword in the query text (MAXDOP 1, RECOMPILE,
-       OPTIMIZE FOR UNKNOWN, NOT IN, a cursor declaration, a row goal's cause) matched the raw
+    /* #579: the rules that look for a hint or a keyword in the query text (MAXDOP 1, MAXDOP 2,
+       RECOMPILE, OPTIMIZE FOR UNKNOWN, NOT IN, a cursor declaration, a row goal's cause) matched the raw
        StatementText, so the words inside a string literal or a comment counted as code. This
        blanks string-literal contents and whole comments with spaces, keeping every other character
        where it was, so a match in the result is a match in the code. The scan follows
        ParameterSubstitution's: '...' with doubled-quote escapes, -- to the end of the line, and
        block comments, which nest in T-SQL. Delimited identifiers ("..." and [...]) are stepped
        over unchanged, so a quote or a dash inside one does not start a string or a comment. */
-    private static string MaskCommentsAndLiterals(string? text)
+    internal static string MaskCommentsAndLiterals(string? text)
     {
         if (string.IsNullOrEmpty(text))
             return "";

src/PlanViewer.Core/Services/PlanAnalyzer.Statement.cs

@@ -408,7 +408,7 @@ private static void Rule38_StandardEditionDop(PlanStatement stmt, AnalyzerConfig
             // Suppress when the user explicitly set MAXDOP 2 as a query hint — the DOP
             // cap is intentional, not the Standard Edition batch-mode limitation.
             var hasMaxdop2Hint = !string.IsNullOrEmpty(stmt.StatementText)
-                && Regex.IsMatch(stmt.StatementText, @"MAXDOP\s+2\b", RegexOptions.IgnoreCase);
+                && Regex.IsMatch(MaskCommentsAndLiterals(stmt.StatementText), @"MAXDOP\s+2\b", RegexOptions.IgnoreCase); // #579
 
             if (!hasMaxdop2Hint)
             {

tests/PlanViewer.Core.Tests/AnalyzerRuleGateTests.cs

@@ -111,6 +111,21 @@ public void Rule06_Rule3ExplainsTheUdf_OneFindingNotTwo()
 
     // ---- #579: text inside string literals and comments is not code -------------------------
 
+    [Theory]
+    // String contents and whole comments become spaces; code, quotes and [identifiers] stay put.
+    [InlineData("SELECT [it's] /* x */ 'y' -- z\nFROM t", "SELECT [it's]         ' '     \nFROM t")]
+    // Block comments nest in T-SQL: the first */ closes only the inner one.
+    [InlineData("a /* 1 /* 2 */ 3 */ b", "a                   b")]
+    // An unclosed string runs to the end, as SQL Server would read it.
+    [InlineData("SELECT 'abc", "SELECT '   ")]
+    public void MaskCommentsAndLiterals_BlanksOnlyLiteralsAndComments(string text, string expected)
+    {
+        var masked = PlanAnalyzer.MaskCommentsAndLiterals(text);
+
+        Assert.Equal(expected, masked);
+        Assert.Equal(text.Length, masked.Length);
+    }
+
     [Theory]
     [InlineData("SELECT 'OPTIMIZE FOR UNKNOWN'")]
     [InlineData("SELECT N'it''s OPTIMIZE FOR UNKNOWN'")]
@@ -158,6 +173,29 @@ public void Rule03_Maxdop1InACommentIsNotAQueryHint(string text, bool expectWarn
         Assert.Equal(expectWarning, Has(stmt, "Serial Plan"));
     }
 
+    [Theory]
+    [InlineData("SELECT a FROM dbo.t -- OPTION (MAXDOP 2)", true)]
+    [InlineData("SELECT a FROM dbo.t OPTION (MAXDOP 2)", false)]
+    public void Rule38_Maxdop2InACommentDoesNotExplainTheDopCap(string text, bool expectWarning)
+    {
+        // A MAXDOP 2 hint makes DOP 2 intentional, so rule 38 stays quiet. A MAXDOP 2 that is
+        // only mentioned in a comment is not a hint. No server metadata: the edition is unknown.
+        var stmt = new PlanStatement
+        {
+            DegreeOfParallelism = 2,
+            StatementText = text,
+            RootNode = new PlanNode
+            {
+                PhysicalOp = "Hash Match",
+                LogicalOp = "Aggregate",
+                ActualExecutionMode = "Batch"
+            }
+        };
+        Analyze(stmt);
+
+        Assert.Equal(expectWarning, Has(stmt, "Standard Edition DOP Limitation"));
+    }
+
     [Theory]
     [InlineData("SELECT a FROM dbo.t WHERE b = @b /* OPTION (RECOMPILE) */", true)]
     [InlineData("SELECT a FROM dbo.t WHERE b = @b OPTION (RECOMPILE)", false)]