Add a basic fixer to suggest replacing intrinsics with their cross-platform counterpart (#7721)

* Add a basic fixer to suggest replacing intrinsics with their cross-platform counterpart

* Remove an unnecessary using

* Ensure we use a new analyzer code, not an existing one

* Make csharp_indent_case_contents_when_block silent until the rest of the repo can be updated

* Don't set csharp_indent_case_contents_when_block in this PR

* Respond to PR feedback

* Fix nullability of the func parameter

* Fix nullability warning on arg0 parameter

* Prefer properties over custom tags

* Fix nullability

* Fix formatting

* Run msbuild /t:pack again

* Check for the existence of Vector64/128/256/512

* Split the tests apart into multiple files

* Mark test class as partial

* Address various PR feedback

* Fix formatting

* Additional cleanup and handle more PR feedback

* Ensure the additional tests compile

* Ensure the generator is passed through

* Ensure the SyntaxGeneratorExtensions are part of the shared project

* Missing semicolon

* Formatting

* Fix tests

Author: tannergooding

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.CSharp.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsAnalyzer.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeQuality.Analyzers.Maintainability;
+
+namespace Microsoft.CodeQuality.CSharp.Analyzers.Maintainability
+{
+    /// <summary>
+    /// CA1516: Use cross-platform intrinsics
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public sealed class CSharpUseCrossPlatformIntrinsicsAnalyzer : UseCrossPlatformIntrinsicsAnalyzer
+    {
+        protected override bool IsSupported(IInvocationOperation invocation, RuleKind ruleKind)
+        {
+            if (invocation.Syntax is not InvocationExpressionSyntax)
+            {
+                return false;
+            }
+
+            return base.IsSupported(invocation, ruleKind);
+        }
+    }
+}

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.CSharp.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsFixer.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using System;
+using System.Composition;
+using System.Diagnostics;
+using Analyzer.Utilities.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeQuality.Analyzers.Maintainability;
+using static Microsoft.CodeQuality.Analyzers.Maintainability.UseCrossPlatformIntrinsicsAnalyzer;
+
+namespace Microsoft.CodeQuality.CSharp.Analyzers.Maintainability
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
+    public sealed class CSharpUseCrossPlatformIntrinsicsFixer : UseCrossPlatformIntrinsicsFixer
+    {
+        protected override SyntaxNode ReplaceNode(SyntaxNode currentNode, SyntaxGenerator generator, RuleKind ruleKind)
+        {
+            return ruleKind switch
+            {
+                RuleKind.op_ExclusiveOr => ReplaceWithBinaryOperator(currentNode, generator, isCommutative: true, generator.ExclusiveOrExpression),
+                RuleKind.op_LeftShift => ReplaceWithBinaryOperator(currentNode, generator, isCommutative: false, generator.LeftShiftExpression),
+                RuleKind.op_RightShift => ReplaceWithBinaryOperator(currentNode, generator, isCommutative: false, generator.RightShiftExpression),
+                RuleKind.op_UnsignedRightShift => ReplaceWithBinaryOperator(currentNode, generator, isCommutative: false, generator.UnsignedRightShiftExpression),
+                _ => base.ReplaceNode(currentNode, generator, ruleKind),
+            };
+        }
+
+        protected override SyntaxNode ReplaceWithBinaryOperator(SyntaxNode currentNode, SyntaxGenerator generator, bool isCommutative, Func<SyntaxNode, SyntaxNode, SyntaxNode?> binaryOpFunc)
+        {
+            if (currentNode is not InvocationExpressionSyntax invocationExpression)
+            {
+                Debug.Fail($"Found unexpected node kind: {currentNode.RawKind}");
+                return currentNode;
+            }
+
+            SeparatedSyntaxList<ArgumentSyntax> arguments = invocationExpression.ArgumentList.Arguments;
+
+            if (arguments.Count != 2)
+            {
+                Debug.Fail($"Found unexpected number of arguments for binary operator replacement: {arguments.Count}");
+                return currentNode;
+            }
+
+            if (binaryOpFunc(arguments[0].Expression, arguments[1].Expression) is not ExpressionSyntax replacementExpression)
+            {
+                return currentNode;
+            }
+
+            return generator.Parenthesize(replacementExpression);
+        }
+
+        protected override SyntaxNode ReplaceWithUnaryOperator(SyntaxNode currentNode, SyntaxGenerator generator, Func<SyntaxNode, SyntaxNode?> unaryOpFunc)
+        {
+            if (currentNode is not InvocationExpressionSyntax invocationExpression)
+            {
+                Debug.Fail($"Found unexpected node kind: {currentNode.RawKind}");
+                return currentNode;
+            }
+
+            SeparatedSyntaxList<ArgumentSyntax> arguments = invocationExpression.ArgumentList.Arguments;
+
+            if (arguments.Count != 1)
+            {
+                Debug.Fail($"Found unexpected number of arguments for unary operator replacement: {arguments.Count}");
+                return currentNode;
+            }
+
+            if (unaryOpFunc(arguments[0].Expression) is not ExpressionSyntax replacementExpression)
+            {
+                return currentNode;
+            }
+
+            return generator.Parenthesize(replacementExpression);
+        }
+    }
+}

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers.md

@@ -936,6 +936,18 @@ Unlike a class library, an application's API isn't typically referenced publicly
 |CodeFix|True|
 ---
 
+## [CA1516](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1516): Use cross-platform intrinsics
+
+This rule detects usage of platform-specific intrinsics that can be replaced with an equivalent cross-platform intrinsic instead.
+
+|Item|Value|
+|-|-|
+|Category|Maintainability|
+|Enabled|True|
+|Severity|Info|
+|CodeFix|True|
+---
+
 ## [CA1700](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1700): Do not name enum values 'Reserved'
 
 This rule assumes that an enumeration member that has a name that contains "reserved" is not currently used but is a placeholder to be renamed or removed in a future version. Renaming or removing a member is a breaking change.

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers.sarif

@@ -145,6 +145,25 @@
             ]
           }
         },
+        "CA1516": {
+          "id": "CA1516",
+          "shortDescription": "Use cross-platform intrinsics",
+          "fullDescription": "This rule detects usage of platform-specific intrinsics that can be replaced with an equivalent cross-platform intrinsic instead.",
+          "defaultLevel": "note",
+          "helpUri": "https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1516",
+          "properties": {
+            "category": "Maintainability",
+            "isEnabledByDefault": true,
+            "typeName": "CSharpUseCrossPlatformIntrinsicsAnalyzer",
+            "languages": [
+              "C#"
+            ],
+            "tags": [
+              "Telemetry",
+              "EnabledRuleInAggressiveMode"
+            ]
+          }
+        },
         "CA1802": {
           "id": "CA1802",
           "shortDescription": "Use literals where appropriate",

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.RuleKind.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+namespace Microsoft.CodeQuality.Analyzers.Maintainability
+{
+    public partial class UseCrossPlatformIntrinsicsAnalyzer
+    {
+        public enum RuleKind
+        {
+            // These names match the underlying IL names for the cross-platform API that will be used in the fixer.
+
+            op_Addition,
+            op_BitwiseAnd,
+            op_BitwiseOr,
+            op_Division,
+            op_ExclusiveOr,
+            op_LeftShift,
+            op_Multiply,
+            op_OnesComplement,
+            op_RightShift,
+            op_Subtraction,
+            op_UnaryNegation,
+            op_UnsignedRightShift,
+
+            Count,
+        }
+    }
+}