Update SA1121 for native-sized integers

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1121CodeFixProvider.cs

@@ -66,8 +66,16 @@ private static SyntaxNode ComputeReplacement(SemanticModel semanticModel, Syntax
 
             var type = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol as INamedTypeSymbol;
 
-            PredefinedTypeSyntax typeSyntax;
-            if (!SpecialTypeHelper.TryGetPredefinedType(type.SpecialType, out typeSyntax))
+            TypeSyntax typeSyntax;
+            if (SpecialTypeHelper.TryGetPredefinedType(type.SpecialType, out var predefinedType))
+            {
+                typeSyntax = predefinedType;
+            }
+            else if (type.SpecialType is SpecialType.System_IntPtr or SpecialType.System_UIntPtr)
+            {
+                typeSyntax = SyntaxFactory.IdentifierName(type.SpecialType == SpecialType.System_IntPtr ? "nint" : "nuint");
+            }
+            else
             {
                 return node;
             }

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/ReadabilityRules/SA1121CSharp11UnitTests.cs

@@ -5,6 +5,7 @@ namespace StyleCop.Analyzers.Test.CSharp11.ReadabilityRules
 {
     using System.Threading;
     using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp10.ReadabilityRules;
     using Xunit;
 
@@ -64,5 +65,54 @@ class TestClass
                 FixedSources = { newSource },
             }.RunAsync(CancellationToken.None).ConfigureAwait(false);
         }
+
+        [Fact]
+        [WorkItem(3969, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3969")]
+        public async Task TestNativeSizedIntegersReportWithNet70Async()
+        {
+            var testCode = @"
+using System;
+
+class TestClass
+{
+    [|IntPtr|] field1;
+    [|System.UIntPtr|] field2;
+}";
+
+            var fixedCode = @"
+using System;
+
+class TestClass
+{
+    nint field1;
+    nuint field2;
+}";
+
+            await new CSharpTest
+            {
+                TestCode = testCode,
+                FixedCode = fixedCode,
+            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3969, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3969")]
+        public async Task TestNativeSizedIntegersDoNotReportWithNet60Async()
+        {
+            var testCode = @"
+using System;
+
+class TestClass
+{
+    IntPtr field1;
+    System.UIntPtr field2;
+}";
+
+            await new CSharpTest
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+                TestCode = testCode,
+            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/ReadabilityRules/SA1121CSharp9UnitTests.cs

@@ -3,9 +3,47 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.ReadabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
+    using StyleCop.Analyzers.Lightup;
     using StyleCop.Analyzers.Test.CSharp8.ReadabilityRules;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1121UseBuiltInTypeAlias,
+        StyleCop.Analyzers.ReadabilityRules.SA1121CodeFixProvider>;
 
     public partial class SA1121CSharp9UnitTests : SA1121CSharp8UnitTests
     {
+        [Fact]
+        [WorkItem(3969, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3969")]
+        public async Task TestNativeSizedIntegersDoNotReportAsync()
+        {
+            // Explicitly test with C# 9 since C# 11 and later include separate coverage where these cases do report.
+            var testCode = @"
+using System;
+
+class TestClass
+{
+    IntPtr field1;
+    System.UIntPtr field2;
+}";
+
+            await VerifyCSharpDiagnosticAsync(LanguageVersionEx.CSharp9, testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3969, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3969")]
+        public async Task TestNativeSizedIntegerAliasesDoNotReportAsync()
+        {
+            var testCode = @"
+class TestClass
+{
+    nint field1;
+    nuint field2;
+}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1121UseBuiltInTypeAlias.cs

@@ -6,7 +6,6 @@
 namespace StyleCop.Analyzers.ReadabilityRules
 {
     using System;
-    using System.Collections.Concurrent;
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
@@ -153,17 +152,19 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            Analyzer analyzer = new Analyzer(context.Compilation.GetOrCreateUsingAliasCache());
+            Analyzer analyzer = new Analyzer(context.Compilation.GetOrCreateUsingAliasCache(), context.Compilation.SupportsNativeSizedIntegers());
             context.RegisterSyntaxNodeAction(analyzer.HandleIdentifierNameSyntax, SyntaxKind.IdentifierName);
         }
 
         private sealed class Analyzer
         {
             private readonly UsingAliasCache usingAliasCache;
+            private readonly bool supportsNativeSizedIntegers;
 
-            public Analyzer(UsingAliasCache usingAliasCache)
+            public Analyzer(UsingAliasCache usingAliasCache, bool supportsNativeSizedIntegers)
             {
                 this.usingAliasCache = usingAliasCache;
+                this.supportsNativeSizedIntegers = supportsNativeSizedIntegers;
             }
 
             public void HandleIdentifierNameSyntax(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
@@ -230,6 +231,7 @@ public void HandleIdentifierNameSyntax(SyntaxNodeAnalysisContext context, StyleC
                     case nameof(UInt16):
                     case nameof(UInt32):
                     case nameof(UInt64):
+                    case nameof(IntPtr) or nameof(UIntPtr) when this.supportsNativeSizedIntegers:
                         break;
 
                     default:
@@ -266,6 +268,7 @@ public void HandleIdentifierNameSyntax(SyntaxNodeAnalysisContext context, StyleC
                 case SpecialType.System_UInt16:
                 case SpecialType.System_UInt32:
                 case SpecialType.System_UInt64:
+                case SpecialType.System_IntPtr or SpecialType.System_UIntPtr when this.supportsNativeSizedIntegers:
                     break;
 
                 default:

documentation/SA1121.md

@@ -47,6 +47,10 @@ The following table lists each of these types in all three formats:
 | uint | UInt32 | System.UInt32 |
 | ulong | UInt64 | System.UInt64 |
 
+### Native-sized integers (C# 11 and .NET 7 or later)
+
+The native-sized integer aliases *nint* and *nuint* were introduced in C# 9. SA1121 considers `IntPtr`/`UIntPtr` and their aliases starting in C# 11 when targeting .NET 7 or later (detected via `System.Runtime.CompilerServices.RuntimeFeature.NumericIntPtr`). In earlier language versions or runtimes, including C# 9, these types do not trigger SA1121 diagnostics.
+
 ## How to fix violations
 
 To fix a violation of this rule, replace the type with the built-in alias for the type.