Fix S2479 FN: Support utf-8 strings, ignore raw and verbatim strings (#6345)

* Fix S2479 FN for utf-8 and utf-8+raw string literals

* Changed S2479 FN comment to Compliant for interpolated strings

* Remove some useless lines fro a testcase

* Empty: Trigger workflows

* S2479 FN Fix: Apply PR Review changes

* Empty: Trigger workflows

* PR Review: Fixed some UTs

* PR Review: Fixed some UTs

* PR Review: Apply changes

* Fix ITs for S2479 FN and also add Net7 on update-expected.ps1

Author: gregory-paidis-sonarsource

analyzers/its/expected/Net7/Net7--net7.0-S2479.json

@@ -2,7 +2,7 @@
 param
 (
     [Parameter(HelpMessage = "The name of single project to update issues for. If ommited, issues for all projects will be updated.")]
-    [ValidateSet("AnalyzeGenerated", "AnalyzeGeneratedVb", "akka.net", "Automapper", "Ember-MM", "Nancy", "NetCore31", "Net5", "Net6", "NetCore31WithConfigurableRules", "ManuallyAddedNoncompliantIssues", "ManuallyAddedNoncompliantIssuesVB", "SkipGenerated", "SkipGeneratedVb", "WebConfig")]
+    [ValidateSet("AnalyzeGenerated", "AnalyzeGeneratedVb", "akka.net", "Automapper", "Ember-MM", "Nancy", "NetCore31", "Net5", "Net6", "Net7", "NetCore31WithConfigurableRules", "ManuallyAddedNoncompliantIssues", "ManuallyAddedNoncompliantIssuesVB", "SkipGenerated", "SkipGeneratedVb", "WebConfig")]
     [string]
     $project
 )

analyzers/its/update-expected.ps1

@@ -31,15 +31,15 @@ namespace SonarAnalyzer.Rules.CSharp
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     public sealed class ControlCharacterInString : SonarDiagnosticAnalyzer
     {
-        internal const string DiagnosticId = "S2479";
+        private const string DiagnosticId = "S2479";
         private const string MessageFormat = "Replace the control character at position {0} by its escape sequence '{1}'.";
 
-        private static readonly DiagnosticDescriptor rule =
+        private static readonly DiagnosticDescriptor Rule =
             DescriptorFactory.Create(DiagnosticId, MessageFormat);
 
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(rule);
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
-        private static readonly IDictionary<char, string> EscapedControlCharacters = new Dictionary<char, string>()
+        private static readonly IDictionary<char, string> EscapedControlCharacters = new Dictionary<char, string>
         {
             {'\u0000', "\\0"},
             {'\u0001', "\\u0001"},
@@ -102,7 +102,8 @@ protected override void Initialize(SonarAnalysisContext context)
         {
             context.RegisterSyntaxNodeActionInNonGenerated(
                 c => CheckControlCharacter(c, ((LiteralExpressionSyntax)c.Node).Token.Text, 0),
-                SyntaxKind.StringLiteralExpression);
+                SyntaxKind.StringLiteralExpression,
+                SyntaxKindEx.Utf8StringLiteralExpression);
 
             context.RegisterSyntaxNodeActionInNonGenerated(
                 c => CheckControlCharacter(c, ((InterpolatedStringTextSyntax)c.Node).TextToken.Text, 1),
@@ -111,7 +112,7 @@ protected override void Initialize(SonarAnalysisContext context)
 
         private static void CheckControlCharacter(SyntaxNodeAnalysisContext c, string text, int displayPosIncrement)
         {
-            if (IsSimpleVerbatimString(c.Node) || IsInterpolatedVerbatimString(c.Node.Parent))
+            if (IsInescapableString(c.Node) || IsInescepableInterpolatedString(c.Node.Parent) || IsInescapableUtf8String(c.Node))
             {
                 return;
             }
@@ -120,17 +121,24 @@ private static void CheckControlCharacter(SyntaxNodeAnalysisContext c, string te
             {
                 if (EscapedControlCharacters.TryGetValue(text[charPos], out var escapeSequence))
                 {
-                    c.ReportIssue(Diagnostic.Create(rule, c.Node.GetLocation(), displayPosIncrement + charPos,
-                        escapeSequence));
+                    c.ReportIssue(Diagnostic.Create(Rule, c.Node.GetLocation(), displayPosIncrement + charPos, escapeSequence));
                     return;
                 }
             }
         }
 
-        private static bool IsSimpleVerbatimString(SyntaxNode syntaxNode) =>
-            syntaxNode.GetFirstToken().IsVerbatimStringLiteral();
+        private static bool IsInescapableString(SyntaxNode syntaxNode) =>
+            syntaxNode.GetFirstToken() is var token
+            && (token.IsVerbatimStringLiteral()
+                || token.IsAnyKind(SyntaxKindEx.SingleLineRawStringLiteralToken, SyntaxKindEx.MultiLineRawStringLiteralToken));
 
-        private static bool IsInterpolatedVerbatimString(SyntaxNode syntaxNode) =>
-            syntaxNode.GetFirstToken().IsKind(SyntaxKind.InterpolatedVerbatimStringStartToken);
+        private static bool IsInescepableInterpolatedString(SyntaxNode syntaxNode) =>
+            syntaxNode.GetFirstToken().IsAnyKind(
+                SyntaxKind.InterpolatedVerbatimStringStartToken,
+                SyntaxKindEx.InterpolatedSingleLineRawStringStartToken,
+                SyntaxKindEx.InterpolatedMultiLineRawStringStartToken);
+
+        private static bool IsInescapableUtf8String(SyntaxNode syntaxNode) =>
+            syntaxNode.GetFirstToken().IsAnyKind(SyntaxKindEx.Utf8SingleLineRawStringLiteralToken, SyntaxKindEx.Utf8MultiLineRawStringLiteralToken);
     }
 }

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

@@ -4,36 +4,46 @@ namespace Tests.Diagnostics
 {
     class Program
     {
-        public const string RawStringLiteralsNonCompliant = """test"""; // Noncompliant
-        public const string RawStringLiteralsCompliant = """test""";
+        public const string RawCompliant = """test"""; // Compliant
+        public const string RawCompliantWithSpecialCharacter = """test"""; // Compliant, raw string
 
-        public const string InterpolatedStringNonCompliant = $"""test{RawStringLiteralsNonCompliant}"""; // FN
-        public const string InterpolatedStringNonCompliant2 = $"""
test{RawStringLiteralsCompliant}"""; // Noncompliant
-        public const string InterpolatedStringCompliant = $"""test{RawStringLiteralsCompliant}""";
+        public const string RawCompliantWithInterpolation = $"""test{RawCompliantWithSpecialCharacter}"""; // Compliant, raw string
+        public const string RawCompliantWithInterpolationAndSpecialCharacter = $"""
test{RawCompliant}"""; // Compliant, raw string
 
         void Utf8StringLiterals()
         {
-            ReadOnlySpan<byte> Utf8Compliant = "test"u8;
-            ReadOnlySpan<byte> Utf8Compliant2 = """test"""u8;
-            ReadOnlySpan<byte> Utf8NonCompliant = "
test"u8; // FN
-            ReadOnlySpan<byte> Uft8NonCompliant2 = """
test"""u8; // FN
+            ReadOnlySpan<byte> Utf8Compliant = "test"u8; // Compliant
+            ReadOnlySpan<byte> Utf8Noncompliant = "
test"u8; // Noncompliant
+            ReadOnlySpan<byte> Utf8VerbatimCompliant = @"
test"u8; // Compliant, verbatim utf-8 string
+
+            ReadOnlySpan<byte> Utf8CompliantRaw = """test"""u8; // Compliant, raw string
+            ReadOnlySpan<byte> Utf8CompliantRawWithSpecialCharacter = """
test"""u8; // Compliant, raw string
         }
 
         void NewlinesInStringInterpolation()
-        { 
-            string NewlinesInterpolatedStringNonCompliant = $"test{RawStringLiteralsNonCompliant +
-                RawStringLiteralsNonCompliant}"; // FN
-            string NewlinesInterpolatedStringNonCompliant2 = $"
test{RawStringLiteralsCompliant +
-                RawStringLiteralsCompliant}"; // Noncompliant@-1
-            string NewlinesInterpolatedStringCompliant = $"test{RawStringLiteralsCompliant +
-                RawStringLiteralsCompliant}";
-
-            string NewlinesInterpolatedStringRawNonCompliant = $$"""test{{RawStringLiteralsNonCompliant +
-                RawStringLiteralsNonCompliant}}"""; // FN
-            string NewlinesInterpolatedStringRawNonCompliant2 = $$"""
test{{RawStringLiteralsCompliant +
-                RawStringLiteralsCompliant}}"""; // Noncompliant@-1
-            string NewlinesInterpolatedStringRawCompliant = $$"""test{{RawStringLiteralsCompliant +
-                RawStringLiteralsCompliant}}""";
+        {
+            var compliant = "test"; // Compliant
+            var nonCompliant = "
test"; // Noncompliant
+
+            var baseCase = $"test{
+                compliant
+                }"; // Compliant
+
+            var interpolatedTextHasControlCharacter = $"test{
+                nonCompliant
+                }"; // Compliant, interpolated text ignored
+
+            var normalTextHasControlCharacter = $"
test{
+                nonCompliant
+                }"; // Noncompliant@-2
+
+            var verbatimWithControlCharacter = @$"
test{
+                nonCompliant
+                }"; // Compliant, verbatim
+
+            var rawWithControlCharacter = $"""
test{
+                nonCompliant
+                }"""; // Compliant, raw
         }
     }
 }