Add FusedMultiplyAdd cross-platform intrinsics support

- Added FusedMultiplyAdd to RuleKind enum
- Added Fma to WellKnownTypeNames
- Registered FusedMultiplyAdd from Fma.MultiplyAdd, AdvSimd.FusedMultiplyAdd, and Avx512F.FusedMultiplyAdd
- Added AddTernaryMethods helper for 3-parameter methods
- Updated fixer to handle FusedMultiplyAdd
- Added resource string for FusedMultiplyAdd diagnostic
- Fixed duplicate Negate registrations (removed from method section since already registered as operator)
- All 554 existing tests pass

Note: Tests for FusedMultiplyAdd cannot be added yet as the API was introduced in .NET 9.0 but test framework only supports up to .NET 8.0 reference assemblies.

Co-authored-by: stephentoub <[email protected]>

Author: Copilot

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

@@ -27,6 +27,7 @@ public enum RuleKind
             Ceiling,
             ConditionalSelect,
             Floor,
+            FusedMultiplyAdd,
             Max,
             Min,
             Negate,

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

@@ -96,7 +96,8 @@ RuleKind.AndNot or
                 RuleKind.Max or
                 RuleKind.Min => IsValidBinaryMethodInvocation(invocation),
 
-                RuleKind.ConditionalSelect => IsValidTernaryMethodInvocation(invocation),
+                RuleKind.ConditionalSelect or
+                RuleKind.FusedMultiplyAdd => IsValidTernaryMethodInvocation(invocation),
 
                 _ => false,
             };
@@ -336,15 +337,16 @@ private void OnCompilationStart(CompilationStartAnalysisContext context)
             {
                 AddUnaryOperatorMethods(methodSymbols, "Abs", armAdvSimdTypeSymbolForMethods, RuleKind.Abs);
                 AddBinaryOperatorMethods(methodSymbols, "AndNot", armAdvSimdTypeSymbolForMethods, RuleKind.AndNot);
+                AddTernaryMethods(methodSymbols, "FusedMultiplyAdd", armAdvSimdTypeSymbolForMethods, RuleKind.FusedMultiplyAdd);
                 AddBinaryOperatorMethods(methodSymbols, "Max", armAdvSimdTypeSymbolForMethods, RuleKind.Max);
                 AddBinaryOperatorMethods(methodSymbols, "Min", armAdvSimdTypeSymbolForMethods, RuleKind.Min);
-                AddUnaryOperatorMethods(methodSymbols, "Negate", armAdvSimdTypeSymbolForMethods, RuleKind.Negate);
+                // Note: Negate is already registered as op_UnaryNegation above, so we don't register it here
             }
 
             if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsArmAdvSimdArm64, out var armAdvSimdArm64TypeSymbolForMethods))
             {
                 AddUnaryOperatorMethods(methodSymbols, "Abs", armAdvSimdArm64TypeSymbolForMethods, RuleKind.Abs);
-                AddUnaryOperatorMethods(methodSymbols, "Negate", armAdvSimdArm64TypeSymbolForMethods, RuleKind.Negate);
+                // Note: Negate is already registered as op_UnaryNegation above, so we don't register it here
             }
 
             if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsWasmPackedSimd, out var wasmPackedSimdTypeSymbolForMethods))
@@ -354,7 +356,7 @@ private void OnCompilationStart(CompilationStartAnalysisContext context)
                 AddUnaryOperatorMethods(methodSymbols, "Floor", wasmPackedSimdTypeSymbolForMethods, RuleKind.Floor);
                 AddBinaryOperatorMethods(methodSymbols, "Max", wasmPackedSimdTypeSymbolForMethods, RuleKind.Max);
                 AddBinaryOperatorMethods(methodSymbols, "Min", wasmPackedSimdTypeSymbolForMethods, RuleKind.Min);
-                AddUnaryOperatorMethods(methodSymbols, "Negate", wasmPackedSimdTypeSymbolForMethods, RuleKind.Negate);
+                // Note: Negate is already registered as op_UnaryNegation above, so we don't register it here
                 AddUnaryOperatorMethods(methodSymbols, "Sqrt", wasmPackedSimdTypeSymbolForMethods, RuleKind.Sqrt);
                 AddUnaryOperatorMethods(methodSymbols, "Truncate", wasmPackedSimdTypeSymbolForMethods, RuleKind.Truncate);
             }
@@ -386,12 +388,18 @@ private void OnCompilationStart(CompilationStartAnalysisContext context)
             if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512F, out var x86Avx512FTypeSymbolForMethods))
             {
                 AddUnaryOperatorMethods(methodSymbols, "Abs", x86Avx512FTypeSymbolForMethods, RuleKind.Abs);
+                AddTernaryMethods(methodSymbols, "FusedMultiplyAdd", x86Avx512FTypeSymbolForMethods, RuleKind.FusedMultiplyAdd);
                 AddBinaryOperatorMethods(methodSymbols, "Max", x86Avx512FTypeSymbolForMethods, RuleKind.Max);
                 AddBinaryOperatorMethods(methodSymbols, "Min", x86Avx512FTypeSymbolForMethods, RuleKind.Min);
                 AddUnaryOperatorMethods(methodSymbols, "RoundToNearestInteger", x86Avx512FTypeSymbolForMethods, RuleKind.Round);
                 AddUnaryOperatorMethods(methodSymbols, "Sqrt", x86Avx512FTypeSymbolForMethods, RuleKind.Sqrt);
             }
 
+            if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Fma, out var x86FmaTypeSymbolForMethods))
+            {
+                AddTernaryMethods(methodSymbols, "MultiplyAdd", x86FmaTypeSymbolForMethods, RuleKind.FusedMultiplyAdd);
+            }
+
             if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Sse, out var x86SseTypeSymbolForMethods))
             {
                 AddBinaryOperatorMethods(methodSymbols, "AndNot", x86SseTypeSymbolForMethods, RuleKind.AndNot);
@@ -476,6 +484,25 @@ m.ReturnType is INamedTypeSymbol namedReturnTypeSymbol &&
 
                 methodSymbols.AddRange(members.Select((m) => new KeyValuePair<IMethodSymbol, RuleKind>(m, ruleKind)));
             }
+
+            static void AddTernaryMethods(Dictionary<IMethodSymbol, RuleKind> methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes)
+            {
+                // Looking for a method with 3 operands, where all are of the same type as the generic return type, such as:
+                //    Vector128<float> FusedMultiplyAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c);
+
+                IEnumerable<IMethodSymbol> members =
+                    typeSymbol.GetMembers(name)
+                              .OfType<IMethodSymbol>()
+                              .Where((m) => m.Parameters.Length == 3 &&
+                                            m.ReturnType is INamedTypeSymbol namedReturnTypeSymbol &&
+                                            namedReturnTypeSymbol.Arity == 1 &&
+                                            ((supportedTypes.Length == 0) || supportedTypes.Contains(namedReturnTypeSymbol.TypeArguments[0].SpecialType)) &&
+                                            SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, namedReturnTypeSymbol) &&
+                                            SymbolEqualityComparer.Default.Equals(m.Parameters[1].Type, namedReturnTypeSymbol) &&
+                                            SymbolEqualityComparer.Default.Equals(m.Parameters[2].Type, namedReturnTypeSymbol));
+
+                methodSymbols.AddRange(members.Select((m) => new KeyValuePair<IMethodSymbol, RuleKind>(m, ruleKind)));
+            }
         }
 
         private void AnalyzeInvocation(OperationAnalysisContext context, Dictionary<IMethodSymbol, RuleKind> methodSymbols)

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsFixer.cs

@@ -70,6 +70,7 @@ protected virtual SyntaxNode ReplaceNode(SyntaxNode currentNode, SyntaxGenerator
                 RuleKind.Min => ReplaceWithBinaryMethod(currentNode, generator, "Min"),
 
                 RuleKind.ConditionalSelect => ReplaceWithTernaryMethod(currentNode, generator, "ConditionalSelect"),
+                RuleKind.FusedMultiplyAdd => ReplaceWithTernaryMethod(currentNode, generator, "FusedMultiplyAdd"),
 
                 _ => currentNode,
             };

src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/MicrosoftCodeQualityAnalyzersResources.resx

@@ -1374,6 +1374,9 @@
   <data name="UseCrossPlatformIntrinsicsMessage_Floor" xml:space="preserve">
     <value>The cross-platform 'Floor' method should be preferred</value>
   </data>
+  <data name="UseCrossPlatformIntrinsicsMessage_FusedMultiplyAdd" xml:space="preserve">
+    <value>The cross-platform 'FusedMultiplyAdd' method should be preferred</value>
+  </data>
   <data name="UseCrossPlatformIntrinsicsMessage_Max" xml:space="preserve">
     <value>The cross-platform 'Max' method should be preferred</value>
   </data>