diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.CSharp.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsFixer.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.CSharp.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsFixer.cs index 3d08c18d4035..aa11ac008aa2 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.CSharp.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsFixer.cs +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.CSharp.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsFixer.cs @@ -75,5 +75,188 @@ protected override SyntaxNode ReplaceWithUnaryOperator(SyntaxNode currentNode, S return generator.Parenthesize(replacementExpression); } + + protected override SyntaxNode ReplaceWithUnaryMethod(SyntaxNode currentNode, SyntaxGenerator generator, string methodName) + { + if (currentNode is not InvocationExpressionSyntax invocationExpression) + { + Debug.Fail($"Found unexpected node kind: {currentNode.RawKind}"); + return currentNode; + } + + SeparatedSyntaxList arguments = invocationExpression.ArgumentList.Arguments; + + if (arguments.Count != 1) + { + Debug.Fail($"Found unexpected number of arguments for unary method replacement: {arguments.Count}"); + return currentNode; + } + + // Determine the vector type name from the return type if available + var vectorTypeName = DetermineVectorTypeName(invocationExpression); + + // Create the cross-platform method call: VectorXXX.MethodName(arg) + // The type parameter will be inferred from the argument + var vectorTypeIdentifier = generator.IdentifierName(vectorTypeName); + var replacementExpression = generator.InvocationExpression( + generator.MemberAccessExpression(vectorTypeIdentifier, methodName), + arguments[0].Expression); + + return generator.Parenthesize(replacementExpression); + } + + protected override SyntaxNode ReplaceWithBinaryMethod(SyntaxNode currentNode, SyntaxGenerator generator, string methodName) + { + if (currentNode is not InvocationExpressionSyntax invocationExpression) + { + Debug.Fail($"Found unexpected node kind: {currentNode.RawKind}"); + return currentNode; + } + + SeparatedSyntaxList arguments = invocationExpression.ArgumentList.Arguments; + + if (arguments.Count != 2) + { + Debug.Fail($"Found unexpected number of arguments for binary method replacement: {arguments.Count}"); + return currentNode; + } + + // Determine the vector type name from the return type if available + var vectorTypeName = DetermineVectorTypeName(invocationExpression); + + // Create the cross-platform method call: VectorXXX.MethodName(arg1, arg2) + // The type parameter will be inferred from the arguments + var vectorTypeIdentifier = generator.IdentifierName(vectorTypeName); + var replacementExpression = generator.InvocationExpression( + generator.MemberAccessExpression(vectorTypeIdentifier, methodName), + arguments[0].Expression, + arguments[1].Expression); + + return generator.Parenthesize(replacementExpression); + } + + protected override SyntaxNode ReplaceWithBinaryMethodSwapped(SyntaxNode currentNode, SyntaxGenerator generator, string methodName) + { + if (currentNode is not InvocationExpressionSyntax invocationExpression) + { + Debug.Fail($"Found unexpected node kind: {currentNode.RawKind}"); + return currentNode; + } + + SeparatedSyntaxList arguments = invocationExpression.ArgumentList.Arguments; + + if (arguments.Count != 2) + { + Debug.Fail($"Found unexpected number of arguments for binary method replacement: {arguments.Count}"); + return currentNode; + } + + // Determine the vector type name from the return type if available + var vectorTypeName = DetermineVectorTypeName(invocationExpression); + + // Create the cross-platform method call with swapped parameters: VectorXXX.MethodName(arg2, arg1) + // For example, Sse.AndNot(x, y) = ~x & y maps to Vector128.AndNot(y, x) = y & ~x + var vectorTypeIdentifier = generator.IdentifierName(vectorTypeName); + var replacementExpression = generator.InvocationExpression( + generator.MemberAccessExpression(vectorTypeIdentifier, methodName), + arguments[1].Expression, // Swap: second argument first + arguments[0].Expression); // Swap: first argument second + + return generator.Parenthesize(replacementExpression); + } + + private static string DetermineVectorTypeName(SyntaxNode node) + { + // For method signatures like "Vector256 M(Vector256 x)", + // we need to find the return type of the method containing this invocation + + // Walk up to find the method declaration + var current = node; + while (current != null) + { + if (current is MethodDeclarationSyntax methodDecl) + { + // Check the return type + var returnType = methodDecl.ReturnType; + if (returnType is GenericNameSyntax genericReturn && + IsVectorType(genericReturn.Identifier.Text)) + { + return genericReturn.Identifier.Text; + } + } + current = current.Parent; + } + + // Also check the invocation itself for argument types + // This handles cases where the invocation is in an expression-bodied member + if (node is InvocationExpressionSyntax invocation) + { + foreach (var arg in invocation.ArgumentList.Arguments) + { + var vectorType = FindVectorTypeInExpression(arg.Expression); + if (vectorType != null) + { + return vectorType; + } + } + } + + // Default to Vector128 if we can't determine the vector type from context. + // This fallback is used when the platform-specific intrinsic call is in a context + // where we cannot infer the return type (e.g., passed as an argument to another method). + // Vector128 is the most common vector size across all platforms. + return "Vector128"; + } + + private static string? FindVectorTypeInExpression(SyntaxNode node) + { + // Look for Vector types in the expression (could be identifiers or generic names) + foreach (var descendant in node.DescendantNodesAndSelf()) + { + if (descendant is GenericNameSyntax genericName && + IsVectorType(genericName.Identifier.Text)) + { + return genericName.Identifier.Text; + } + } + return null; + } + + /// + /// Checks if the given type name is a Vector type (Vector64, Vector128, Vector256, or Vector512). + /// + private static bool IsVectorType(string typeName) + => typeName is "Vector64" or "Vector128" or "Vector256" or "Vector512"; + + protected override SyntaxNode ReplaceWithTernaryMethod(SyntaxNode currentNode, SyntaxGenerator generator, string methodName) + { + if (currentNode is not InvocationExpressionSyntax invocationExpression) + { + Debug.Fail($"Found unexpected node kind: {currentNode.RawKind}"); + return currentNode; + } + + SeparatedSyntaxList arguments = invocationExpression.ArgumentList.Arguments; + + if (arguments.Count != 3) + { + Debug.Fail($"Found unexpected number of arguments for ternary method replacement: {arguments.Count}"); + return currentNode; + } + + // Determine the vector type name from the return type if available + var vectorTypeName = DetermineVectorTypeName(invocationExpression); + + // Create the cross-platform method call: VectorXXX.MethodName(arg1, arg2, arg3) + // The type parameter will be inferred from the arguments + var vectorTypeIdentifier = generator.IdentifierName(vectorTypeName); + var replacementExpression = generator.InvocationExpression( + generator.MemberAccessExpression(vectorTypeIdentifier, methodName), + arguments[0].Expression, + arguments[1].Expression, + arguments[2].Expression); + + return generator.Parenthesize(replacementExpression); + } } } diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.RuleKind.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.RuleKind.cs index 5e63a749be90..e807671bc4c7 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.RuleKind.cs +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.RuleKind.cs @@ -6,7 +6,7 @@ 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. + // These names match the underlying IL names or method names for the cross-platform API that will be used in the fixer. op_Addition, op_BitwiseAnd, @@ -21,6 +21,35 @@ public enum RuleKind op_UnaryNegation, op_UnsignedRightShift, + // Named methods (not operators) + Abs, + AddSaturate, + AndNot, // For ARM BitwiseClear - direct parameter mapping + AndNot_Swapped, // For x86/x64 AndNot - needs parameter swap + Ceiling, + ConditionalSelect, + ConvertToInt32, + Equals, + Floor, + FusedMultiplyAdd, + GetElement, + GreaterThan, + GreaterThanOrEqual, + LessThan, + LessThanOrEqual, + Max, + MaxNative, // For x86/x64 Max - different NaN/negative zero handling + Min, + MinNative, // For x86/x64 Min - different NaN/negative zero handling + Negate, + Round, + Sqrt, + Truncate, + WithElement, + Load, + Store, + Shuffle, + Count, } } diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.cs index af68e5472678..117e2ab6aa66 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.cs +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsAnalyzer.cs @@ -84,9 +84,52 @@ RuleKind.op_RightShift or RuleKind.op_OnesComplement or RuleKind.op_UnaryNegation => IsValidUnaryOperatorMethodInvocation(invocation), + RuleKind.Abs or + RuleKind.Ceiling or + RuleKind.ConvertToInt32 or + RuleKind.Floor or + RuleKind.Negate or + RuleKind.Round or + RuleKind.Sqrt or + RuleKind.Truncate => IsValidUnaryMethodInvocation(invocation), + + RuleKind.AddSaturate or + RuleKind.AndNot or + RuleKind.AndNot_Swapped or + RuleKind.Equals or + RuleKind.GreaterThan or + RuleKind.GreaterThanOrEqual or + RuleKind.LessThan or + RuleKind.LessThanOrEqual or + RuleKind.Max or + RuleKind.MaxNative or + RuleKind.Min or + RuleKind.MinNative => IsValidBinaryMethodInvocation(invocation), + + RuleKind.ConditionalSelect or + RuleKind.FusedMultiplyAdd => IsValidTernaryMethodInvocation(invocation), + + RuleKind.Load => IsValidLoadMethodInvocation(invocation), + + RuleKind.Store => IsValidStoreMethodInvocation(invocation), + _ => false, }; + static bool IsValidLoadMethodInvocation(IInvocationOperation invocation) + { + // Load methods typically have one parameter (pointer/reference) and return a vector + return (invocation.Arguments.Length >= 1) && + invocation.Type is INamedTypeSymbol { IsGenericType: true }; + } + + static bool IsValidStoreMethodInvocation(IInvocationOperation invocation) + { + // Store methods typically have two parameters (pointer/reference and vector) and return void + return (invocation.Arguments.Length >= 2) && + (invocation.Type?.SpecialType == SpecialType.System_Void); + } + static bool IsValidBinaryOperatorMethodInvocation(IInvocationOperation invocation, bool isCommutative) { return (invocation.Arguments.Length == 2) && @@ -108,6 +151,27 @@ static bool IsValidUnaryOperatorMethodInvocation(IInvocationOperation invocation return (invocation.Arguments.Length == 1) && SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[0].Parameter?.Type); } + + static bool IsValidUnaryMethodInvocation(IInvocationOperation invocation) + { + return (invocation.Arguments.Length == 1) && + SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[0].Parameter?.Type); + } + + static bool IsValidBinaryMethodInvocation(IInvocationOperation invocation) + { + return (invocation.Arguments.Length == 2) && + SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[0].Parameter?.Type) && + SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[1].Parameter?.Type); + } + + static bool IsValidTernaryMethodInvocation(IInvocationOperation invocation) + { + return (invocation.Arguments.Length == 3) && + SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[0].Parameter?.Type) && + SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[1].Parameter?.Type) && + SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[2].Parameter?.Type); + } } private void OnCompilationStart(CompilationStartAnalysisContext context) @@ -140,158 +204,345 @@ private void OnCompilationStart(CompilationStartAnalysisContext context) if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsArmAdvSimd, out var armAdvSimdTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", armAdvSimdTypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "AddScalar", armAdvSimdTypeSymbol, RuleKind.op_Addition, [SpecialType.System_Int64, SpecialType.System_UInt64, SpecialType.System_Double]); - AddBinaryOperatorMethods(methodSymbols, "And", armAdvSimdTypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "DivideScalar", armAdvSimdTypeSymbol, RuleKind.op_Division, [SpecialType.System_Double]); - AddBinaryOperatorMethods(methodSymbols, "Multiply", armAdvSimdTypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "MultiplyScalar", armAdvSimdTypeSymbol, RuleKind.op_Multiply, [SpecialType.System_Double]); - AddBinaryOperatorMethods(methodSymbols, "Or", armAdvSimdTypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Subtract", armAdvSimdTypeSymbol, RuleKind.op_Subtraction); - AddBinaryOperatorMethods(methodSymbols, "SubtractScalar", armAdvSimdTypeSymbol, RuleKind.op_Subtraction, [SpecialType.System_Int64, SpecialType.System_UInt64, SpecialType.System_Double]); - AddBinaryOperatorMethods(methodSymbols, "Xor", armAdvSimdTypeSymbol, RuleKind.op_ExclusiveOr); - - AddShiftOperatorMethods(methodSymbols, "ShiftLeftLogical", armAdvSimdTypeSymbol, RuleKind.op_LeftShift); - AddShiftOperatorMethods(methodSymbols, "ShiftLeftLogicalScalar", armAdvSimdTypeSymbol, RuleKind.op_LeftShift, [SpecialType.System_Int64, SpecialType.System_UInt64]); - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmetic", armAdvSimdTypeSymbol, RuleKind.op_RightShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmeticScalar", armAdvSimdTypeSymbol, RuleKind.op_RightShift, [SpecialType.System_Int64, SpecialType.System_UInt64]); - AddShiftOperatorMethods(methodSymbols, "ShiftRightLogical", armAdvSimdTypeSymbol, RuleKind.op_UnsignedRightShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightLogicalScalar", armAdvSimdTypeSymbol, RuleKind.op_UnsignedRightShift, [SpecialType.System_Int64, SpecialType.System_UInt64]); - - AddUnaryOperatorMethods(methodSymbols, "Negate", armAdvSimdTypeSymbol, RuleKind.op_UnaryNegation); - AddUnaryOperatorMethods(methodSymbols, "NegateScalar", armAdvSimdTypeSymbol, RuleKind.op_UnaryNegation, [SpecialType.System_Double]); - AddUnaryOperatorMethods(methodSymbols, "Not", armAdvSimdTypeSymbol, RuleKind.op_OnesComplement); + AddBinaryMethods(methodSymbols, "Add", armAdvSimdTypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "AddScalar", armAdvSimdTypeSymbol, RuleKind.op_Addition, [SpecialType.System_Int64, SpecialType.System_UInt64, SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "And", armAdvSimdTypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "DivideScalar", armAdvSimdTypeSymbol, RuleKind.op_Division, [SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "Multiply", armAdvSimdTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "MultiplyScalar", armAdvSimdTypeSymbol, RuleKind.op_Multiply, [SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "Or", armAdvSimdTypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Subtract", armAdvSimdTypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "SubtractScalar", armAdvSimdTypeSymbol, RuleKind.op_Subtraction, [SpecialType.System_Int64, SpecialType.System_UInt64, SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "Xor", armAdvSimdTypeSymbol, RuleKind.op_ExclusiveOr); + + AddShiftMethods(methodSymbols, "ShiftLeftLogical", armAdvSimdTypeSymbol, RuleKind.op_LeftShift); + AddShiftMethods(methodSymbols, "ShiftLeftLogicalScalar", armAdvSimdTypeSymbol, RuleKind.op_LeftShift, [SpecialType.System_Int64, SpecialType.System_UInt64]); + AddShiftMethods(methodSymbols, "ShiftRightArithmetic", armAdvSimdTypeSymbol, RuleKind.op_RightShift); + AddShiftMethods(methodSymbols, "ShiftRightArithmeticScalar", armAdvSimdTypeSymbol, RuleKind.op_RightShift, [SpecialType.System_Int64, SpecialType.System_UInt64]); + AddShiftMethods(methodSymbols, "ShiftRightLogical", armAdvSimdTypeSymbol, RuleKind.op_UnsignedRightShift); + AddShiftMethods(methodSymbols, "ShiftRightLogicalScalar", armAdvSimdTypeSymbol, RuleKind.op_UnsignedRightShift, [SpecialType.System_Int64, SpecialType.System_UInt64]); + + AddUnaryMethods(methodSymbols, "Negate", armAdvSimdTypeSymbol, RuleKind.op_UnaryNegation); + AddUnaryMethods(methodSymbols, "NegateScalar", armAdvSimdTypeSymbol, RuleKind.op_UnaryNegation, [SpecialType.System_Double]); + AddUnaryMethods(methodSymbols, "Not", armAdvSimdTypeSymbol, RuleKind.op_OnesComplement); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsArmAdvSimdArm64, out var armAdvSimdArm64TypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", armAdvSimdArm64TypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "Divide", armAdvSimdArm64TypeSymbol, RuleKind.op_Division); - AddBinaryOperatorMethods(methodSymbols, "Multiply", armAdvSimdArm64TypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Subtract", armAdvSimdArm64TypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Add", armAdvSimdArm64TypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "Divide", armAdvSimdArm64TypeSymbol, RuleKind.op_Division); + AddBinaryMethods(methodSymbols, "Multiply", armAdvSimdArm64TypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Subtract", armAdvSimdArm64TypeSymbol, RuleKind.op_Subtraction); - AddUnaryOperatorMethods(methodSymbols, "Negate", armAdvSimdArm64TypeSymbol, RuleKind.op_UnaryNegation); - AddUnaryOperatorMethods(methodSymbols, "NegateScalar", armAdvSimdArm64TypeSymbol, RuleKind.op_UnaryNegation, [SpecialType.System_Int64]); + AddUnaryMethods(methodSymbols, "Negate", armAdvSimdArm64TypeSymbol, RuleKind.op_UnaryNegation); + AddUnaryMethods(methodSymbols, "NegateScalar", armAdvSimdArm64TypeSymbol, RuleKind.op_UnaryNegation, [SpecialType.System_Int64]); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsWasmPackedSimd, out var wasmPackedSimdTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", wasmPackedSimdTypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "And", wasmPackedSimdTypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "Divide", wasmPackedSimdTypeSymbol, RuleKind.op_Division); - AddBinaryOperatorMethods(methodSymbols, "Multiply", wasmPackedSimdTypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Or", wasmPackedSimdTypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Subtract", wasmPackedSimdTypeSymbol, RuleKind.op_Subtraction); - AddBinaryOperatorMethods(methodSymbols, "Xor", wasmPackedSimdTypeSymbol, RuleKind.op_ExclusiveOr); - - AddShiftOperatorMethods(methodSymbols, "ShiftLeft", wasmPackedSimdTypeSymbol, RuleKind.op_LeftShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmetic", wasmPackedSimdTypeSymbol, RuleKind.op_RightShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightLogical", wasmPackedSimdTypeSymbol, RuleKind.op_UnsignedRightShift); - - AddUnaryOperatorMethods(methodSymbols, "Negate", wasmPackedSimdTypeSymbol, RuleKind.op_UnaryNegation); - AddUnaryOperatorMethods(methodSymbols, "Not", wasmPackedSimdTypeSymbol, RuleKind.op_OnesComplement); + AddBinaryMethods(methodSymbols, "Add", wasmPackedSimdTypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "And", wasmPackedSimdTypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "Divide", wasmPackedSimdTypeSymbol, RuleKind.op_Division); + AddBinaryMethods(methodSymbols, "Multiply", wasmPackedSimdTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Or", wasmPackedSimdTypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Subtract", wasmPackedSimdTypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Xor", wasmPackedSimdTypeSymbol, RuleKind.op_ExclusiveOr); + + AddShiftMethods(methodSymbols, "ShiftLeft", wasmPackedSimdTypeSymbol, RuleKind.op_LeftShift); + AddShiftMethods(methodSymbols, "ShiftRightArithmetic", wasmPackedSimdTypeSymbol, RuleKind.op_RightShift); + AddShiftMethods(methodSymbols, "ShiftRightLogical", wasmPackedSimdTypeSymbol, RuleKind.op_UnsignedRightShift); + + AddUnaryMethods(methodSymbols, "Negate", wasmPackedSimdTypeSymbol, RuleKind.op_UnaryNegation); + AddUnaryMethods(methodSymbols, "Not", wasmPackedSimdTypeSymbol, RuleKind.op_OnesComplement); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx, out var x86AvxTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", x86AvxTypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "And", x86AvxTypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "Divide", x86AvxTypeSymbol, RuleKind.op_Division); - AddBinaryOperatorMethods(methodSymbols, "Multiply", x86AvxTypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Or", x86AvxTypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Subtract", x86AvxTypeSymbol, RuleKind.op_Subtraction); - AddBinaryOperatorMethods(methodSymbols, "Xor", x86AvxTypeSymbol, RuleKind.op_ExclusiveOr); + AddBinaryMethods(methodSymbols, "Add", x86AvxTypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "And", x86AvxTypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "Divide", x86AvxTypeSymbol, RuleKind.op_Division); + AddBinaryMethods(methodSymbols, "Multiply", x86AvxTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Or", x86AvxTypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Subtract", x86AvxTypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Xor", x86AvxTypeSymbol, RuleKind.op_ExclusiveOr); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx2, out var x86Avx2TypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", x86Avx2TypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "And", x86Avx2TypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "MultiplyLow", x86Avx2TypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Or", x86Avx2TypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Subtract", x86Avx2TypeSymbol, RuleKind.op_Subtraction); - AddBinaryOperatorMethods(methodSymbols, "Xor", x86Avx2TypeSymbol, RuleKind.op_ExclusiveOr); - - AddShiftOperatorMethods(methodSymbols, "ShiftLeftLogical", x86Avx2TypeSymbol, RuleKind.op_LeftShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmetic", x86Avx2TypeSymbol, RuleKind.op_RightShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightLogical", x86Avx2TypeSymbol, RuleKind.op_UnsignedRightShift); + AddBinaryMethods(methodSymbols, "Add", x86Avx2TypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "And", x86Avx2TypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "MultiplyLow", x86Avx2TypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Or", x86Avx2TypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Subtract", x86Avx2TypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Xor", x86Avx2TypeSymbol, RuleKind.op_ExclusiveOr); + + AddShiftMethods(methodSymbols, "ShiftLeftLogical", x86Avx2TypeSymbol, RuleKind.op_LeftShift); + AddShiftMethods(methodSymbols, "ShiftRightArithmetic", x86Avx2TypeSymbol, RuleKind.op_RightShift); + AddShiftMethods(methodSymbols, "ShiftRightLogical", x86Avx2TypeSymbol, RuleKind.op_UnsignedRightShift); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512BW, out var x86Avx512BWTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", x86Avx512BWTypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "MultiplyLow", x86Avx512BWTypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Subtract", x86Avx512BWTypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Add", x86Avx512BWTypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "MultiplyLow", x86Avx512BWTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Subtract", x86Avx512BWTypeSymbol, RuleKind.op_Subtraction); - AddShiftOperatorMethods(methodSymbols, "ShiftLeftLogical", x86Avx512BWTypeSymbol, RuleKind.op_LeftShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmetic", x86Avx512BWTypeSymbol, RuleKind.op_RightShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightLogical", x86Avx512BWTypeSymbol, RuleKind.op_UnsignedRightShift); + AddShiftMethods(methodSymbols, "ShiftLeftLogical", x86Avx512BWTypeSymbol, RuleKind.op_LeftShift); + AddShiftMethods(methodSymbols, "ShiftRightArithmetic", x86Avx512BWTypeSymbol, RuleKind.op_RightShift); + AddShiftMethods(methodSymbols, "ShiftRightLogical", x86Avx512BWTypeSymbol, RuleKind.op_UnsignedRightShift); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512DQ, out var x86Avx512DQTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "And", x86Avx512DQTypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "MultiplyLow", x86Avx512DQTypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Or", x86Avx512DQTypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Xor", x86Avx512DQTypeSymbol, RuleKind.op_ExclusiveOr); + AddBinaryMethods(methodSymbols, "And", x86Avx512DQTypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "MultiplyLow", x86Avx512DQTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Or", x86Avx512DQTypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Xor", x86Avx512DQTypeSymbol, RuleKind.op_ExclusiveOr); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512DQVL, out var x86Avx512DQVLTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "MultiplyLow", x86Avx512DQVLTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "MultiplyLow", x86Avx512DQVLTypeSymbol, RuleKind.op_Multiply); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512F, out var x86Avx512FTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", x86Avx512FTypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "And", x86Avx512FTypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "Divide", x86Avx512FTypeSymbol, RuleKind.op_Division); - AddBinaryOperatorMethods(methodSymbols, "Multiply", x86Avx512FTypeSymbol, RuleKind.op_Multiply, [SpecialType.System_Single, SpecialType.System_Double]); - AddBinaryOperatorMethods(methodSymbols, "MultiplyLow", x86Avx512FTypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Or", x86Avx512FTypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Subtract", x86Avx512FTypeSymbol, RuleKind.op_Subtraction); - AddBinaryOperatorMethods(methodSymbols, "Xor", x86Avx512FTypeSymbol, RuleKind.op_ExclusiveOr); - - AddShiftOperatorMethods(methodSymbols, "ShiftLeftLogical", x86Avx512FTypeSymbol, RuleKind.op_LeftShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmetic", x86Avx512FTypeSymbol, RuleKind.op_RightShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightLogical", x86Avx512FTypeSymbol, RuleKind.op_UnsignedRightShift); + AddBinaryMethods(methodSymbols, "Add", x86Avx512FTypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "And", x86Avx512FTypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "Divide", x86Avx512FTypeSymbol, RuleKind.op_Division); + AddBinaryMethods(methodSymbols, "Multiply", x86Avx512FTypeSymbol, RuleKind.op_Multiply, [SpecialType.System_Single, SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "MultiplyLow", x86Avx512FTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Or", x86Avx512FTypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Subtract", x86Avx512FTypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Xor", x86Avx512FTypeSymbol, RuleKind.op_ExclusiveOr); + + AddShiftMethods(methodSymbols, "ShiftLeftLogical", x86Avx512FTypeSymbol, RuleKind.op_LeftShift); + AddShiftMethods(methodSymbols, "ShiftRightArithmetic", x86Avx512FTypeSymbol, RuleKind.op_RightShift); + AddShiftMethods(methodSymbols, "ShiftRightLogical", x86Avx512FTypeSymbol, RuleKind.op_UnsignedRightShift); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512FVL, out var x86Avx512FVLTypeSymbol)) { - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmetic", x86Avx512FVLTypeSymbol, RuleKind.op_RightShift); + AddShiftMethods(methodSymbols, "ShiftRightArithmetic", x86Avx512FVLTypeSymbol, RuleKind.op_RightShift); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Sse, out var x86SseTypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", x86SseTypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "And", x86SseTypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "Divide", x86SseTypeSymbol, RuleKind.op_Division); - AddBinaryOperatorMethods(methodSymbols, "Multiply", x86SseTypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Or", x86SseTypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Subtract", x86SseTypeSymbol, RuleKind.op_Subtraction); - AddBinaryOperatorMethods(methodSymbols, "Xor", x86SseTypeSymbol, RuleKind.op_ExclusiveOr); + AddBinaryMethods(methodSymbols, "Add", x86SseTypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "And", x86SseTypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "Divide", x86SseTypeSymbol, RuleKind.op_Division); + AddBinaryMethods(methodSymbols, "Multiply", x86SseTypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Or", x86SseTypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Subtract", x86SseTypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Xor", x86SseTypeSymbol, RuleKind.op_ExclusiveOr); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Sse2, out var x86Sse2TypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "Add", x86Sse2TypeSymbol, RuleKind.op_Addition); - AddBinaryOperatorMethods(methodSymbols, "And", x86Sse2TypeSymbol, RuleKind.op_BitwiseAnd); - AddBinaryOperatorMethods(methodSymbols, "Divide", x86Sse2TypeSymbol, RuleKind.op_Division); - AddBinaryOperatorMethods(methodSymbols, "Multiply", x86Sse2TypeSymbol, RuleKind.op_Multiply, [SpecialType.System_Double]); - AddBinaryOperatorMethods(methodSymbols, "MultiplyLow", x86Sse2TypeSymbol, RuleKind.op_Multiply); - AddBinaryOperatorMethods(methodSymbols, "Or", x86Sse2TypeSymbol, RuleKind.op_BitwiseOr); - AddBinaryOperatorMethods(methodSymbols, "Subtract", x86Sse2TypeSymbol, RuleKind.op_Subtraction); - AddBinaryOperatorMethods(methodSymbols, "Xor", x86Sse2TypeSymbol, RuleKind.op_ExclusiveOr); - - AddShiftOperatorMethods(methodSymbols, "ShiftLeftLogical", x86Sse2TypeSymbol, RuleKind.op_LeftShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightArithmetic", x86Sse2TypeSymbol, RuleKind.op_RightShift); - AddShiftOperatorMethods(methodSymbols, "ShiftRightLogical", x86Sse2TypeSymbol, RuleKind.op_UnsignedRightShift); + AddBinaryMethods(methodSymbols, "Add", x86Sse2TypeSymbol, RuleKind.op_Addition); + AddBinaryMethods(methodSymbols, "And", x86Sse2TypeSymbol, RuleKind.op_BitwiseAnd); + AddBinaryMethods(methodSymbols, "AndNot", x86Sse2TypeSymbol, RuleKind.AndNot_Swapped); + AddBinaryMethods(methodSymbols, "Divide", x86Sse2TypeSymbol, RuleKind.op_Division); + AddBinaryMethods(methodSymbols, "Multiply", x86Sse2TypeSymbol, RuleKind.op_Multiply, [SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "MultiplyLow", x86Sse2TypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "Or", x86Sse2TypeSymbol, RuleKind.op_BitwiseOr); + AddBinaryMethods(methodSymbols, "Subtract", x86Sse2TypeSymbol, RuleKind.op_Subtraction); + AddBinaryMethods(methodSymbols, "Xor", x86Sse2TypeSymbol, RuleKind.op_ExclusiveOr); + + AddShiftMethods(methodSymbols, "ShiftLeftLogical", x86Sse2TypeSymbol, RuleKind.op_LeftShift); + AddShiftMethods(methodSymbols, "ShiftRightArithmetic", x86Sse2TypeSymbol, RuleKind.op_RightShift); + AddShiftMethods(methodSymbols, "ShiftRightLogical", x86Sse2TypeSymbol, RuleKind.op_UnsignedRightShift); } if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Sse41, out var x86Sse41TypeSymbol)) { - AddBinaryOperatorMethods(methodSymbols, "MultiplyLow", x86Sse41TypeSymbol, RuleKind.op_Multiply); + AddBinaryMethods(methodSymbols, "MultiplyLow", x86Sse41TypeSymbol, RuleKind.op_Multiply); + } + + // Register named methods (not operators) that have cross-platform equivalents + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsArmAdvSimd, out var armAdvSimdTypeSymbolForMethods)) + { + // Note: AdvSimd.Abs for integer types returns unsigned types (e.g., Vector128 → Vector128), + // so we only register floating-point Abs which has compatible signatures + AddUnaryMethods(methodSymbols, "Abs", armAdvSimdTypeSymbolForMethods, RuleKind.Abs, [SpecialType.System_Single]); + AddUnaryMethods(methodSymbols, "AbsScalar", armAdvSimdTypeSymbolForMethods, RuleKind.Abs, [SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "AddSaturate", armAdvSimdTypeSymbolForMethods, RuleKind.AddSaturate); + AddBinaryMethods(methodSymbols, "BitwiseClear", armAdvSimdTypeSymbolForMethods, RuleKind.AndNot); + AddTernaryMethods(methodSymbols, "BitwiseSelect", armAdvSimdTypeSymbolForMethods, RuleKind.ConditionalSelect); + AddUnaryMethods(methodSymbols, "Ceiling", armAdvSimdTypeSymbolForMethods, RuleKind.Ceiling); + AddUnaryMethods(methodSymbols, "CeilingScalar", armAdvSimdTypeSymbolForMethods, RuleKind.Ceiling); + AddBinaryMethods(methodSymbols, "CompareEqual", armAdvSimdTypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", armAdvSimdTypeSymbolForMethods, RuleKind.GreaterThan); + AddBinaryMethods(methodSymbols, "CompareGreaterThanOrEqual", armAdvSimdTypeSymbolForMethods, RuleKind.GreaterThanOrEqual); + AddBinaryMethods(methodSymbols, "CompareLessThan", armAdvSimdTypeSymbolForMethods, RuleKind.LessThan); + AddBinaryMethods(methodSymbols, "CompareLessThanOrEqual", armAdvSimdTypeSymbolForMethods, RuleKind.LessThanOrEqual); + AddUnaryMethods(methodSymbols, "ConvertToInt32RoundToZero", armAdvSimdTypeSymbolForMethods, RuleKind.ConvertToInt32); + AddUnaryMethods(methodSymbols, "ConvertToInt32RoundToZeroScalar", armAdvSimdTypeSymbolForMethods, RuleKind.ConvertToInt32); + // Extract maps to GetElement - needs index parameter handling in fixer + // TODO: Implement Extract → GetElement transformation + AddUnaryMethods(methodSymbols, "Floor", armAdvSimdTypeSymbolForMethods, RuleKind.Floor); + AddUnaryMethods(methodSymbols, "FloorScalar", armAdvSimdTypeSymbolForMethods, RuleKind.Floor); + AddTernaryMethods(methodSymbols, "FusedMultiplyAdd", armAdvSimdTypeSymbolForMethods, RuleKind.FusedMultiplyAdd); + // FusedMultiplySubtract and variants need parameter negation/reordering in fixer + // TODO: Implement FusedMultiplySubtract transformations + // Insert maps to WithElement - needs index parameter handling in fixer + // TODO: Implement Insert → WithElement transformation + AddBinaryMethods(methodSymbols, "Max", armAdvSimdTypeSymbolForMethods, RuleKind.Max); + AddBinaryMethods(methodSymbols, "Min", armAdvSimdTypeSymbolForMethods, RuleKind.Min); + // Note: Negate is already registered as op_UnaryNegation above, so we don't register it here + // Note: MultiplyAdd(x, y, z) expands to (y * z) + x - needs operator expansion + // TODO: Implement MultiplyAdd → operator expansion transformation + // Note: OrNot expands to two operators - needs operator expansion + // TODO: Implement OrNot → operator expansion transformation + AddUnaryMethods(methodSymbols, "RoundToNearest", armAdvSimdTypeSymbolForMethods, RuleKind.Round); + AddUnaryMethods(methodSymbols, "RoundToNegativeInfinity", armAdvSimdTypeSymbolForMethods, RuleKind.Floor); + AddUnaryMethods(methodSymbols, "RoundToPositiveInfinity", armAdvSimdTypeSymbolForMethods, RuleKind.Ceiling); + AddUnaryMethods(methodSymbols, "RoundToZero", armAdvSimdTypeSymbolForMethods, RuleKind.Truncate); + // Note: Sqrt is already registered above as operator method + AddLoadMethods(methodSymbols, "LoadVector64", armAdvSimdTypeSymbolForMethods, RuleKind.Load); + AddLoadMethods(methodSymbols, "LoadVector128", armAdvSimdTypeSymbolForMethods, RuleKind.Load); + AddStoreMethods(methodSymbols, "Store", armAdvSimdTypeSymbolForMethods, RuleKind.Store); + // VectorTableLookup is 1-to-1 with Shuffle for byte/sbyte + AddBinaryMethods(methodSymbols, "VectorTableLookup", armAdvSimdTypeSymbolForMethods, RuleKind.Shuffle, [SpecialType.System_Byte, SpecialType.System_SByte]); + // Note: Shuffle/Create APIs like Duplicate, ExtractVector128 need complex transformations (constant extraction) + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsArmAdvSimdArm64, out var armAdvSimdArm64TypeSymbolForMethods)) + { + // Note: AdvSimd.Arm64.Abs for integer types returns unsigned types (e.g., Vector128 → Vector128), + // so we only register AbsScalar for compatible types + AddUnaryMethods(methodSymbols, "AbsScalar", armAdvSimdArm64TypeSymbolForMethods, RuleKind.Abs, [SpecialType.System_Double]); + AddBinaryMethods(methodSymbols, "AddSaturateScalar", armAdvSimdArm64TypeSymbolForMethods, RuleKind.AddSaturate); + // Note: Negate is already registered as op_UnaryNegation above, so we don't register it here + // TODO: Add scalar variants of Extract/Insert, FusedMultiply*, Round* + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsWasmPackedSimd, out var wasmPackedSimdTypeSymbolForMethods)) + { + AddUnaryMethods(methodSymbols, "Abs", wasmPackedSimdTypeSymbolForMethods, RuleKind.Abs); + AddUnaryMethods(methodSymbols, "Ceiling", wasmPackedSimdTypeSymbolForMethods, RuleKind.Ceiling); + AddBinaryMethods(methodSymbols, "CompareEqual", wasmPackedSimdTypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", wasmPackedSimdTypeSymbolForMethods, RuleKind.GreaterThan); + AddBinaryMethods(methodSymbols, "CompareGreaterThanOrEqual", wasmPackedSimdTypeSymbolForMethods, RuleKind.GreaterThanOrEqual); + AddBinaryMethods(methodSymbols, "CompareLessThan", wasmPackedSimdTypeSymbolForMethods, RuleKind.LessThan); + AddBinaryMethods(methodSymbols, "CompareLessThanOrEqual", wasmPackedSimdTypeSymbolForMethods, RuleKind.LessThanOrEqual); + AddUnaryMethods(methodSymbols, "Floor", wasmPackedSimdTypeSymbolForMethods, RuleKind.Floor); + AddBinaryMethods(methodSymbols, "Max", wasmPackedSimdTypeSymbolForMethods, RuleKind.Max); + AddBinaryMethods(methodSymbols, "Min", wasmPackedSimdTypeSymbolForMethods, RuleKind.Min); + // Note: Negate is already registered as op_UnaryNegation above, so we don't register it here + AddUnaryMethods(methodSymbols, "Sqrt", wasmPackedSimdTypeSymbolForMethods, RuleKind.Sqrt); + AddUnaryMethods(methodSymbols, "Truncate", wasmPackedSimdTypeSymbolForMethods, RuleKind.Truncate); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx, out var x86AvxTypeSymbolForMethods)) + { + AddBinaryMethods(methodSymbols, "AddSaturate", x86AvxTypeSymbolForMethods, RuleKind.AddSaturate); + AddBinaryMethods(methodSymbols, "AndNot", x86AvxTypeSymbolForMethods, RuleKind.AndNot_Swapped); + AddTernaryMethods(methodSymbols, "BlendVariable", x86AvxTypeSymbolForMethods, RuleKind.ConditionalSelect); + AddUnaryMethods(methodSymbols, "Ceiling", x86AvxTypeSymbolForMethods, RuleKind.Ceiling); + AddBinaryMethods(methodSymbols, "CompareEqual", x86AvxTypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", x86AvxTypeSymbolForMethods, RuleKind.GreaterThan); + AddBinaryMethods(methodSymbols, "CompareLessThan", x86AvxTypeSymbolForMethods, RuleKind.LessThan); + AddUnaryMethods(methodSymbols, "ConvertToVector128Int32", x86AvxTypeSymbolForMethods, RuleKind.ConvertToInt32); + AddUnaryMethods(methodSymbols, "ConvertToVector256Int32", x86AvxTypeSymbolForMethods, RuleKind.ConvertToInt32); + AddUnaryMethods(methodSymbols, "Floor", x86AvxTypeSymbolForMethods, RuleKind.Floor); + AddBinaryMethods(methodSymbols, "Max", x86AvxTypeSymbolForMethods, RuleKind.MaxNative); + AddBinaryMethods(methodSymbols, "Min", x86AvxTypeSymbolForMethods, RuleKind.MinNative); + AddUnaryMethods(methodSymbols, "RoundToNearestInteger", x86AvxTypeSymbolForMethods, RuleKind.Round); + AddUnaryMethods(methodSymbols, "RoundToNegativeInfinity", x86AvxTypeSymbolForMethods, RuleKind.Floor); + AddUnaryMethods(methodSymbols, "RoundToPositiveInfinity", x86AvxTypeSymbolForMethods, RuleKind.Ceiling); + AddUnaryMethods(methodSymbols, "RoundToZero", x86AvxTypeSymbolForMethods, RuleKind.Truncate); + AddUnaryMethods(methodSymbols, "Sqrt", x86AvxTypeSymbolForMethods, RuleKind.Sqrt); + AddLoadMethods(methodSymbols, "LoadVector256", x86AvxTypeSymbolForMethods, RuleKind.Load); + AddStoreMethods(methodSymbols, "Store", x86AvxTypeSymbolForMethods, RuleKind.Store); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx2, out var x86Avx2TypeSymbolForMethods)) + { + AddUnaryMethods(methodSymbols, "Abs", x86Avx2TypeSymbolForMethods, RuleKind.Abs); + AddBinaryMethods(methodSymbols, "AddSaturate", x86Avx2TypeSymbolForMethods, RuleKind.AddSaturate); + AddTernaryMethods(methodSymbols, "BlendVariable", x86Avx2TypeSymbolForMethods, RuleKind.ConditionalSelect); + AddBinaryMethods(methodSymbols, "CompareEqual", x86Avx2TypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", x86Avx2TypeSymbolForMethods, RuleKind.GreaterThan); + AddLoadMethods(methodSymbols, "LoadVector256", x86Avx2TypeSymbolForMethods, RuleKind.Load); + AddStoreMethods(methodSymbols, "Store", x86Avx2TypeSymbolForMethods, RuleKind.Store); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512BW, out var x86Avx512BWTypeSymbolForMethods)) + { + AddUnaryMethods(methodSymbols, "Abs", x86Avx512BWTypeSymbolForMethods, RuleKind.Abs); + AddBinaryMethods(methodSymbols, "AddSaturate", x86Avx512BWTypeSymbolForMethods, RuleKind.AddSaturate); + AddBinaryMethods(methodSymbols, "CompareEqual", x86Avx512BWTypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", x86Avx512BWTypeSymbolForMethods, RuleKind.GreaterThan); + AddBinaryMethods(methodSymbols, "CompareGreaterThanOrEqual", x86Avx512BWTypeSymbolForMethods, RuleKind.GreaterThanOrEqual); + AddBinaryMethods(methodSymbols, "CompareLessThan", x86Avx512BWTypeSymbolForMethods, RuleKind.LessThan); + AddBinaryMethods(methodSymbols, "CompareLessThanOrEqual", x86Avx512BWTypeSymbolForMethods, RuleKind.LessThanOrEqual); + AddLoadMethods(methodSymbols, "LoadVector512", x86Avx512BWTypeSymbolForMethods, RuleKind.Load); + AddStoreMethods(methodSymbols, "Store", x86Avx512BWTypeSymbolForMethods, RuleKind.Store); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Avx512F, out var x86Avx512FTypeSymbolForMethods)) + { + AddUnaryMethods(methodSymbols, "Abs", x86Avx512FTypeSymbolForMethods, RuleKind.Abs); + AddBinaryMethods(methodSymbols, "CompareEqual", x86Avx512FTypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", x86Avx512FTypeSymbolForMethods, RuleKind.GreaterThan); + AddBinaryMethods(methodSymbols, "CompareGreaterThanOrEqual", x86Avx512FTypeSymbolForMethods, RuleKind.GreaterThanOrEqual); + AddBinaryMethods(methodSymbols, "CompareLessThan", x86Avx512FTypeSymbolForMethods, RuleKind.LessThan); + AddBinaryMethods(methodSymbols, "CompareLessThanOrEqual", x86Avx512FTypeSymbolForMethods, RuleKind.LessThanOrEqual); + AddUnaryMethods(methodSymbols, "ConvertToVector128Int32", x86Avx512FTypeSymbolForMethods, RuleKind.ConvertToInt32); + AddUnaryMethods(methodSymbols, "ConvertToVector256Int32", x86Avx512FTypeSymbolForMethods, RuleKind.ConvertToInt32); + AddTernaryMethods(methodSymbols, "FusedMultiplyAdd", x86Avx512FTypeSymbolForMethods, RuleKind.FusedMultiplyAdd); + AddBinaryMethods(methodSymbols, "Max", x86Avx512FTypeSymbolForMethods, RuleKind.MaxNative); + AddBinaryMethods(methodSymbols, "Min", x86Avx512FTypeSymbolForMethods, RuleKind.MinNative); + AddUnaryMethods(methodSymbols, "RoundToNearestInteger", x86Avx512FTypeSymbolForMethods, RuleKind.Round); + AddUnaryMethods(methodSymbols, "Sqrt", x86Avx512FTypeSymbolForMethods, RuleKind.Sqrt); + AddLoadMethods(methodSymbols, "LoadVector512", x86Avx512FTypeSymbolForMethods, RuleKind.Load); + AddStoreMethods(methodSymbols, "Store", x86Avx512FTypeSymbolForMethods, RuleKind.Store); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Fma, out var x86FmaTypeSymbolForMethods)) + { + AddTernaryMethods(methodSymbols, "MultiplyAdd", x86FmaTypeSymbolForMethods, RuleKind.FusedMultiplyAdd); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Sse, out var x86SseTypeSymbolForMethods)) + { + AddBinaryMethods(methodSymbols, "AndNot", x86SseTypeSymbolForMethods, RuleKind.AndNot_Swapped); + AddBinaryMethods(methodSymbols, "CompareEqual", x86SseTypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", x86SseTypeSymbolForMethods, RuleKind.GreaterThan); + AddBinaryMethods(methodSymbols, "CompareLessThan", x86SseTypeSymbolForMethods, RuleKind.LessThan); + AddLoadMethods(methodSymbols, "LoadVector128", x86SseTypeSymbolForMethods, RuleKind.Load); + AddBinaryMethods(methodSymbols, "Max", x86SseTypeSymbolForMethods, RuleKind.MaxNative); + AddBinaryMethods(methodSymbols, "Min", x86SseTypeSymbolForMethods, RuleKind.MinNative); + AddUnaryMethods(methodSymbols, "Sqrt", x86SseTypeSymbolForMethods, RuleKind.Sqrt); + AddStoreMethods(methodSymbols, "Store", x86SseTypeSymbolForMethods, RuleKind.Store); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Sse2, out var x86Sse2TypeSymbolForMethods)) + { + AddBinaryMethods(methodSymbols, "AddSaturate", x86Sse2TypeSymbolForMethods, RuleKind.AddSaturate); + AddBinaryMethods(methodSymbols, "CompareEqual", x86Sse2TypeSymbolForMethods, RuleKind.Equals); + AddBinaryMethods(methodSymbols, "CompareGreaterThan", x86Sse2TypeSymbolForMethods, RuleKind.GreaterThan); + AddBinaryMethods(methodSymbols, "CompareLessThan", x86Sse2TypeSymbolForMethods, RuleKind.LessThan); + AddUnaryMethods(methodSymbols, "ConvertToVector128Int32", x86Sse2TypeSymbolForMethods, RuleKind.ConvertToInt32); + AddLoadMethods(methodSymbols, "LoadVector128", x86Sse2TypeSymbolForMethods, RuleKind.Load); + AddUnaryMethods(methodSymbols, "Sqrt", x86Sse2TypeSymbolForMethods, RuleKind.Sqrt); + AddStoreMethods(methodSymbols, "Store", x86Sse2TypeSymbolForMethods, RuleKind.Store); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Sse41, out var x86Sse41TypeSymbolForMethods)) + { + AddTernaryMethods(methodSymbols, "BlendVariable", x86Sse41TypeSymbolForMethods, RuleKind.ConditionalSelect); + AddUnaryMethods(methodSymbols, "RoundToNearestInteger", x86Sse41TypeSymbolForMethods, RuleKind.Round); + AddUnaryMethods(methodSymbols, "RoundToNegativeInfinity", x86Sse41TypeSymbolForMethods, RuleKind.Floor); + AddUnaryMethods(methodSymbols, "RoundToPositiveInfinity", x86Sse41TypeSymbolForMethods, RuleKind.Ceiling); + AddUnaryMethods(methodSymbols, "RoundToZero", x86Sse41TypeSymbolForMethods, RuleKind.Truncate); + } + + if (compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeIntrinsicsX86Ssse3, out var x86Ssse3TypeSymbolForMethods)) + { + AddUnaryMethods(methodSymbols, "Abs", x86Ssse3TypeSymbolForMethods, RuleKind.Abs); } if (methodSymbols.Any()) @@ -299,10 +550,11 @@ private void OnCompilationStart(CompilationStartAnalysisContext context) context.RegisterOperationAction((context) => AnalyzeInvocation(context, methodSymbols), OperationKind.Invocation); } - static void AddBinaryOperatorMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) + static void AddBinaryMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) { - // Looking for a method with 2 operands, where the both are of the same type as the generic return type, such as: + // Looking for a method with 2 operands, where both are of the same type as the generic return type, such as: // Vector128 Add(Vector128 x, Vector128 y); + // This is used for both operator replacements (e.g., Add → +) and method replacements (e.g., Max → Vector128.Max) IEnumerable members = typeSymbol.GetMembers(name) @@ -317,7 +569,7 @@ m.ReturnType is INamedTypeSymbol namedReturnTypeSymbol && methodSymbols.AddRange(members.Select((m) => new KeyValuePair(m, ruleKind))); } - static void AddShiftOperatorMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) + static void AddShiftMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) { // Looking for a method with 2 operands, where the first is of the same type as the generic return type and the second is byte or int, such as: // Vector128 LeftShift(Vector128 x, byte y); @@ -336,10 +588,11 @@ m.ReturnType is INamedTypeSymbol namedReturnTypeSymbol && methodSymbols.AddRange(members.Select((m) => new KeyValuePair(m, ruleKind))); } - static void AddUnaryOperatorMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) + static void AddUnaryMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) { // Looking for a method with 1 operand, where it is of the same type as the generic return type, such as: // Vector128 Negate(Vector128 operand); + // This is used for both operator replacements (e.g., Negate → unary -) and method replacements (e.g., Sqrt → Vector128.Sqrt) IEnumerable members = typeSymbol.GetMembers(name) @@ -352,6 +605,59 @@ m.ReturnType is INamedTypeSymbol namedReturnTypeSymbol && methodSymbols.AddRange(members.Select((m) => new KeyValuePair(m, ruleKind))); } + + static void AddTernaryMethods(Dictionary 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 FusedMultiplyAdd(Vector128 a, Vector128 b, Vector128 c); + + IEnumerable members = + typeSymbol.GetMembers(name) + .OfType() + .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(m, ruleKind))); + } + + static void AddLoadMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) + { + // Looking for Load methods that take a pointer/reference and return a vector, such as: + // Vector128 LoadVector128(byte* address); + // Vector128 LoadVector128(ref byte source); + + IEnumerable members = + typeSymbol.GetMembers(name) + .OfType() + .Where((m) => m.Parameters.Length >= 1 && + m.ReturnType is INamedTypeSymbol namedReturnTypeSymbol && + namedReturnTypeSymbol.Arity == 1 && + ((supportedTypes.Length == 0) || supportedTypes.Contains(namedReturnTypeSymbol.TypeArguments[0].SpecialType))); + + methodSymbols.AddRange(members.Select((m) => new KeyValuePair(m, ruleKind))); + } + + static void AddStoreMethods(Dictionary methodSymbols, string name, INamedTypeSymbol typeSymbol, RuleKind ruleKind, params SpecialType[] supportedTypes) + { + // Looking for Store methods that take a pointer/reference and a vector, and return void, such as: + // void Store(byte* address, Vector128 source); + // void Store(ref byte destination, Vector128 source); + + IEnumerable members = + typeSymbol.GetMembers(name) + .OfType() + .Where((m) => m.Parameters.Length >= 2 && + m.ReturnType?.SpecialType == SpecialType.System_Void && + m.Parameters.Any(p => p.Type is INamedTypeSymbol { Arity: 1 } paramType && + ((supportedTypes.Length == 0) || supportedTypes.Contains(paramType.TypeArguments[0].SpecialType)))); + + methodSymbols.AddRange(members.Select((m) => new KeyValuePair(m, ruleKind))); + } } private void AnalyzeInvocation(OperationAnalysisContext context, Dictionary methodSymbols) diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsFixer.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsFixer.cs index 40337438ae08..da904556c114 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsFixer.cs +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/Maintainability/UseCrossPlatformIntrinsicsFixer.cs @@ -56,6 +56,36 @@ protected virtual SyntaxNode ReplaceNode(SyntaxNode currentNode, SyntaxGenerator RuleKind.op_OnesComplement => ReplaceWithUnaryOperator(currentNode, generator, generator.BitwiseNotExpression), RuleKind.op_Subtraction => ReplaceWithBinaryOperator(currentNode, generator, isCommutative: false, generator.SubtractExpression), RuleKind.op_UnaryNegation => ReplaceWithUnaryOperator(currentNode, generator, generator.NegateExpression), + + RuleKind.Abs => ReplaceWithUnaryMethod(currentNode, generator, "Abs"), + RuleKind.Ceiling => ReplaceWithUnaryMethod(currentNode, generator, "Ceiling"), + RuleKind.ConvertToInt32 => ReplaceWithUnaryMethod(currentNode, generator, "ConvertToInt32"), + RuleKind.Floor => ReplaceWithUnaryMethod(currentNode, generator, "Floor"), + RuleKind.Negate => ReplaceWithUnaryMethod(currentNode, generator, "Negate"), + RuleKind.Round => ReplaceWithUnaryMethod(currentNode, generator, "Round"), + RuleKind.Sqrt => ReplaceWithUnaryMethod(currentNode, generator, "Sqrt"), + RuleKind.Truncate => ReplaceWithUnaryMethod(currentNode, generator, "Truncate"), + + RuleKind.AddSaturate => ReplaceWithBinaryMethod(currentNode, generator, "AddSaturate"), + RuleKind.AndNot => ReplaceWithBinaryMethod(currentNode, generator, "AndNot"), + RuleKind.AndNot_Swapped => ReplaceWithBinaryMethodSwapped(currentNode, generator, "AndNot"), + RuleKind.Equals => ReplaceWithBinaryMethod(currentNode, generator, "Equals"), + RuleKind.GreaterThan => ReplaceWithBinaryMethod(currentNode, generator, "GreaterThan"), + RuleKind.GreaterThanOrEqual => ReplaceWithBinaryMethod(currentNode, generator, "GreaterThanOrEqual"), + RuleKind.LessThan => ReplaceWithBinaryMethod(currentNode, generator, "LessThan"), + RuleKind.LessThanOrEqual => ReplaceWithBinaryMethod(currentNode, generator, "LessThanOrEqual"), + RuleKind.Max => ReplaceWithBinaryMethod(currentNode, generator, "Max"), + RuleKind.MaxNative => ReplaceWithBinaryMethod(currentNode, generator, "MaxNative"), + RuleKind.Min => ReplaceWithBinaryMethod(currentNode, generator, "Min"), + RuleKind.MinNative => ReplaceWithBinaryMethod(currentNode, generator, "MinNative"), + + RuleKind.ConditionalSelect => ReplaceWithTernaryMethod(currentNode, generator, "ConditionalSelect"), + RuleKind.FusedMultiplyAdd => ReplaceWithTernaryMethod(currentNode, generator, "FusedMultiplyAdd"), + + RuleKind.Load => ReplaceWithUnaryMethod(currentNode, generator, "Load"), + RuleKind.Store => ReplaceWithBinaryMethod(currentNode, generator, "Store"), + RuleKind.Shuffle => ReplaceWithBinaryMethod(currentNode, generator, "Shuffle"), + _ => currentNode, }; } @@ -63,5 +93,13 @@ protected virtual SyntaxNode ReplaceNode(SyntaxNode currentNode, SyntaxGenerator protected abstract SyntaxNode ReplaceWithUnaryOperator(SyntaxNode currentNode, SyntaxGenerator generator, Func unaryOpFunc); protected abstract SyntaxNode ReplaceWithBinaryOperator(SyntaxNode currentNode, SyntaxGenerator generator, bool isCommutative, Func binaryOpFunc); + + protected abstract SyntaxNode ReplaceWithUnaryMethod(SyntaxNode currentNode, SyntaxGenerator generator, string methodName); + + protected abstract SyntaxNode ReplaceWithBinaryMethod(SyntaxNode currentNode, SyntaxGenerator generator, string methodName); + + protected abstract SyntaxNode ReplaceWithBinaryMethodSwapped(SyntaxNode currentNode, SyntaxGenerator generator, string methodName); + + protected abstract SyntaxNode ReplaceWithTernaryMethod(SyntaxNode currentNode, SyntaxGenerator generator, string methodName); } } \ No newline at end of file diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/MicrosoftCodeQualityAnalyzersResources.resx b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/MicrosoftCodeQualityAnalyzersResources.resx index ced35802d544..740a5b07566e 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/MicrosoftCodeQualityAnalyzersResources.resx +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/MicrosoftCodeQualityAnalyzersResources.resx @@ -1365,4 +1365,82 @@ The unsigned right-shift operator should be preferred + + The cross-platform 'Abs' method should be preferred + + + The cross-platform 'Ceiling' method should be preferred + + + The cross-platform 'Floor' method should be preferred + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + The cross-platform 'Max' method should be preferred + + + The cross-platform 'Min' method should be preferred + + + The cross-platform 'Sqrt' method should be preferred + + + The cross-platform 'AddSaturate' method should be preferred + + + The cross-platform 'AndNot' method should be preferred + + + The cross-platform 'AndNot' method should be preferred + + + The cross-platform 'ConditionalSelect' method should be preferred + + + The cross-platform 'ConvertToInt32' method should be preferred + + + The cross-platform 'Equals' method should be preferred + + + The cross-platform 'GetElement' method should be preferred + + + The cross-platform 'GreaterThan' method should be preferred + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + The cross-platform 'LessThan' method should be preferred + + + The cross-platform 'LessThanOrEqual' method should be preferred + + + The cross-platform 'MaxNative' method should be preferred + + + The cross-platform 'MinNative' method should be preferred + + + The cross-platform 'Negate' method should be preferred + + + The cross-platform 'Round' method should be preferred + + + The cross-platform 'Truncate' method should be preferred + + + The cross-platform 'WithElement' method should be preferred + + + The cross-platform 'Load' method should be preferred + + + The cross-platform 'Store' method should be preferred + \ No newline at end of file diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf index 993d27a7e27a..db3b96e28e9c 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf @@ -447,6 +447,136 @@ Toto pravidlo detekuje použití vnitřních hodnot specifických pro platformu, které lze místo toho nahradit ekvivalentními vnitřními hodnotami pro různé platformy. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred Upřednostňuje se operátor sčítání. diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf index 2d72ce86724e..d5d928bf3b38 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf @@ -447,6 +447,136 @@ Diese Regel erkennt die Verwendung plattformspezifischer systeminterner Funktionen, die durch ein entsprechendes plattformübergreifendes Äquivalent ersetzt werden können. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred Der Additionsoperator sollte bevorzugt verwendet werden. diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf index d0c894d545bd..afc9f4ca887d 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf @@ -447,6 +447,136 @@ Esta regla detecta el uso de intrínsecos específicos de la plataforma que se pueden reemplazar por un intrínseco multiplataforma equivalente en su lugar. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred Se debe preferir el operador de suma diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf index c0d87275f1f8..d0782c472ec5 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf @@ -447,6 +447,136 @@ Cette règle détecte l’utilisation d’intrinsèques spécifiques à la plateforme qui peuvent être remplacés par un équivalent multiplateforme. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred L’opérateur d’addition doit être préféré diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf index 0d3f77a35113..e903b06202a3 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf @@ -447,6 +447,136 @@ Questa regola rileva l'utilizzo di intrinseci specifici della piattaforma che possono essere sostituiti con un intrinseco equivalente multipiattaforma. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred È consigliabile preferire l'operatore di addizione diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf index 2598ba3ea59a..e2a7d7a0b902 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf @@ -447,6 +447,136 @@ このルールは、代わりに同等のクロスプラットフォーム組み込み関数に置き換えることができるプラットフォーム固有の組み込み関数の使用を検出します。 + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred 加算演算子を優先する必要があります diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf index 3e9bb3c7c02b..5e7cf06c188f 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf @@ -447,6 +447,136 @@ 이 규칙은 플랫폼별 내장 기능의 사용을 감지하며, 이를 동일한 플랫폼 간 내장으로 대체할 수 있습니다. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred 더하기 연산자를 선호해야 합니다. diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf index 946f8a34a065..927c30a76cf5 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf @@ -447,6 +447,136 @@ Ta reguła wykrywa użycie funkcji wewnętrznych specyficznych dla platformy, które można zastąpić równoważną wewnętrzną funkcją międzyplatformową. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred Preferowany powinien być operator addition diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf index efc329512fb9..b8aead327e25 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf @@ -447,6 +447,136 @@ Esta regra detecta o uso de intrínsecos específicos da plataforma que podem ser substituídos por um intrínseco multiplataforma equivalente. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred Deve-se dar preferência ao operador de adição diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf index 92e30c889f10..99750b2b6e5a 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf @@ -447,6 +447,136 @@ Это правило обнаруживает использование встроенных функций, специфичных для платформы, которые можно заменить эквивалентной кроссплатформенной встроенной функцией. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred Следует предпочитать оператор сложения diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf index ecbf6c8b0b96..791dac381abb 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf @@ -447,6 +447,136 @@ Bu kural, eşdeğer platformlar arası iç öğe ile değiştirilebilecek, platforma özgü iç öğe kullanımını algılar. + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred Toplama işleci tercih edilmelidir diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf index e37314f611f9..85682a54bb83 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf @@ -447,6 +447,136 @@ 此规则检测特定于平台的内部函数的使用情况，这些内部函数可以替换为等效的跨平台内部函数。 + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred 应优先使用加法运算符 diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf index 2133b933c138..cca1081c17aa 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Microsoft.CodeAnalysis.NetAnalyzers/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf @@ -447,6 +447,136 @@ 此規則會偵測平台特定的內建使用情況，這些內建可以被對應的跨平台內建所取代。 + + The cross-platform 'Abs' method should be preferred + The cross-platform 'Abs' method should be preferred + + + + The cross-platform 'AddSaturate' method should be preferred + The cross-platform 'AddSaturate' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'AndNot' method should be preferred + The cross-platform 'AndNot' method should be preferred + + + + The cross-platform 'Ceiling' method should be preferred + The cross-platform 'Ceiling' method should be preferred + + + + The cross-platform 'ConditionalSelect' method should be preferred + The cross-platform 'ConditionalSelect' method should be preferred + + + + The cross-platform 'ConvertToInt32' method should be preferred + The cross-platform 'ConvertToInt32' method should be preferred + + + + The cross-platform 'Equals' method should be preferred + The cross-platform 'Equals' method should be preferred + + + + The cross-platform 'Floor' method should be preferred + The cross-platform 'Floor' method should be preferred + + + + The cross-platform 'FusedMultiplyAdd' method should be preferred + The cross-platform 'FusedMultiplyAdd' method should be preferred + + + + The cross-platform 'GetElement' method should be preferred + The cross-platform 'GetElement' method should be preferred + + + + The cross-platform 'GreaterThan' method should be preferred + The cross-platform 'GreaterThan' method should be preferred + + + + The cross-platform 'GreaterThanOrEqual' method should be preferred + The cross-platform 'GreaterThanOrEqual' method should be preferred + + + + The cross-platform 'LessThan' method should be preferred + The cross-platform 'LessThan' method should be preferred + + + + The cross-platform 'LessThanOrEqual' method should be preferred + The cross-platform 'LessThanOrEqual' method should be preferred + + + + The cross-platform 'Load' method should be preferred + The cross-platform 'Load' method should be preferred + + + + The cross-platform 'Max' method should be preferred + The cross-platform 'Max' method should be preferred + + + + The cross-platform 'MaxNative' method should be preferred + The cross-platform 'MaxNative' method should be preferred + + + + The cross-platform 'Min' method should be preferred + The cross-platform 'Min' method should be preferred + + + + The cross-platform 'MinNative' method should be preferred + The cross-platform 'MinNative' method should be preferred + + + + The cross-platform 'Negate' method should be preferred + The cross-platform 'Negate' method should be preferred + + + + The cross-platform 'Round' method should be preferred + The cross-platform 'Round' method should be preferred + + + + The cross-platform 'Sqrt' method should be preferred + The cross-platform 'Sqrt' method should be preferred + + + + The cross-platform 'Store' method should be preferred + The cross-platform 'Store' method should be preferred + + + + The cross-platform 'Truncate' method should be preferred + The cross-platform 'Truncate' method should be preferred + + + + The cross-platform 'WithElement' method should be preferred + The cross-platform 'WithElement' method should be preferred + + The addition operator should be preferred 應優先使用加法運算子 diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/RulesMissingDocumentation.md b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/RulesMissingDocumentation.md index c5820fde91ae..75e0f77588e2 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/RulesMissingDocumentation.md +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/RulesMissingDocumentation.md @@ -2,7 +2,3 @@ Rule ID | Missing Help Link | Title | --------|-------------------|-------| -CA1873 | | Avoid potentially expensive logging | -CA1874 | | Use 'Regex.IsMatch' | -CA1875 | | Use 'Regex.Count' | -CA2023 | | Invalid braces in message template | diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Utilities/Compiler/WellKnownTypeNames.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Utilities/Compiler/WellKnownTypeNames.cs index af724317d84f..dc56f4627b81 100644 --- a/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Utilities/Compiler/WellKnownTypeNames.cs +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/src/Utilities/Compiler/WellKnownTypeNames.cs @@ -371,9 +371,11 @@ internal static class WellKnownTypeNames public const string SystemRuntimeIntrinsicsX86Avx512DQVL = "System.Runtime.Intrinsics.X86.Avx512DQ+VL"; public const string SystemRuntimeIntrinsicsX86Avx512F = "System.Runtime.Intrinsics.X86.Avx512F"; public const string SystemRuntimeIntrinsicsX86Avx512FVL = "System.Runtime.Intrinsics.X86.Avx512F+VL"; + public const string SystemRuntimeIntrinsicsX86Fma = "System.Runtime.Intrinsics.X86.Fma"; public const string SystemRuntimeIntrinsicsX86Sse = "System.Runtime.Intrinsics.X86.Sse"; public const string SystemRuntimeIntrinsicsX86Sse2 = "System.Runtime.Intrinsics.X86.Sse2"; public const string SystemRuntimeIntrinsicsX86Sse41 = "System.Runtime.Intrinsics.X86.Sse41"; + public const string SystemRuntimeIntrinsicsX86Ssse3 = "System.Runtime.Intrinsics.X86.Ssse3"; public const string SystemRuntimeSerializationDataContractAttribute = "System.Runtime.Serialization.DataContractAttribute"; public const string SystemRuntimeSerializationDataContractSerializer = "System.Runtime.Serialization.DataContractSerializer"; public const string SystemRuntimeSerializationDataMemberAttribute = "System.Runtime.Serialization.DataMemberAttribute"; diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.Abs.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.Abs.cs new file mode 100644 index 000000000000..4c3af080801b --- /dev/null +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.Abs.cs @@ -0,0 +1,99 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the MIT license. See License.txt in the project root for license information. + +using System.Threading.Tasks; +using Microsoft.CodeAnalysis.Testing; +using Xunit; +using VerifyCS = Test.Utilities.CSharpCodeFixVerifier< + Microsoft.CodeQuality.CSharp.Analyzers.Maintainability.CSharpUseCrossPlatformIntrinsicsAnalyzer, + Microsoft.CodeQuality.CSharp.Analyzers.Maintainability.CSharpUseCrossPlatformIntrinsicsFixer>; + +namespace Microsoft.CodeQuality.Analyzers.Maintainability.UnitTests +{ + using static UseCrossPlatformIntrinsicsAnalyzer; + + public partial class CSharpUseCrossPlatformIntrinsicsTests + { + [Theory] + [InlineData("sbyte", "PackedSimd.Abs")] + [InlineData("short", "PackedSimd.Abs")] + [InlineData("int", "PackedSimd.Abs")] + [InlineData("long", "PackedSimd.Abs")] + [InlineData("float", "PackedSimd.Abs")] + [InlineData("double", "PackedSimd.Abs")] + public async Task Fixer_AbsWasmAsync(string type, string method) + { + // lang=C#-test + string testCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Wasm; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x) => {|#1:{{method}}(x)|}; + } + """; + + // lang=C#-test + string fixedCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Wasm; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x) => Vector128.Abs(x); + } + """; + + await new VerifyCS.Test + { + TestCode = testCode, + ExpectedDiagnostics = { + VerifyCS.Diagnostic(Rules[(int)RuleKind.Abs]).WithLocation(1), + }, + FixedCode = fixedCode, + ReferenceAssemblies = ReferenceAssemblies.Net.Net80 + }.RunAsync(); + } + + [Theory] + [InlineData("float", "AdvSimd.Abs")] + public async Task Fixer_AbsAdvSimdAsync(string type, string method) + { + // lang=C#-test + string testCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Arm; + + class C + { + Vector64<{{type}}> M(Vector64<{{type}}> x) => {|#1:{{method}}(x)|}; + } + """; + + // lang=C#-test + string fixedCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Arm; + + class C + { + Vector64<{{type}}> M(Vector64<{{type}}> x) => Vector64.Abs(x); + } + """; + + await new VerifyCS.Test + { + TestCode = testCode, + ExpectedDiagnostics = { + VerifyCS.Diagnostic(Rules[(int)RuleKind.Abs]).WithLocation(1), + }, + FixedCode = fixedCode, + ReferenceAssemblies = ReferenceAssemblies.Net.Net80 + }.RunAsync(); + } + } +} diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.MinMax.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.MinMax.cs new file mode 100644 index 000000000000..90cf3b2c7506 --- /dev/null +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.MinMax.cs @@ -0,0 +1,114 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the MIT license. See License.txt in the project root for license information. + +using System.Threading.Tasks; +using Microsoft.CodeAnalysis.Testing; +using Xunit; +using VerifyCS = Test.Utilities.CSharpCodeFixVerifier< + Microsoft.CodeQuality.CSharp.Analyzers.Maintainability.CSharpUseCrossPlatformIntrinsicsAnalyzer, + Microsoft.CodeQuality.CSharp.Analyzers.Maintainability.CSharpUseCrossPlatformIntrinsicsFixer>; + +namespace Microsoft.CodeQuality.Analyzers.Maintainability.UnitTests +{ + using static UseCrossPlatformIntrinsicsAnalyzer; + + public partial class CSharpUseCrossPlatformIntrinsicsTests + { + [Theory(Skip = "MaxNative/MinNative are .NET 9+ APIs not available in test framework")] + [InlineData("float", "Sse.Max")] + [InlineData("float", "Sse.Min")] + public async Task Fixer_MinMaxSseAsync(string type, string method) + { + var ruleKind = method.Contains("Max") ? RuleKind.MaxNative : RuleKind.MinNative; + var expectedMethod = method.Contains("Max") ? "MaxNative" : "MinNative"; + + // lang=C#-test + string testCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.X86; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x, Vector128<{{type}}> y) => {|#1:{{method}}(x, y)|}; + } + """; + + // lang=C#-test + string fixedCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.X86; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x, Vector128<{{type}}> y) => Vector128.{{expectedMethod}}(x, y); + } + """; + + await new VerifyCS.Test + { + TestCode = testCode, + ExpectedDiagnostics = { + VerifyCS.Diagnostic(Rules[(int)ruleKind]).WithLocation(1), + }, + FixedCode = fixedCode, + ReferenceAssemblies = ReferenceAssemblies.Net.Net80 + }.RunAsync(); + } + + [Theory] + [InlineData("byte", "AdvSimd.Max")] + [InlineData("byte", "AdvSimd.Min")] + [InlineData("sbyte", "AdvSimd.Max")] + [InlineData("sbyte", "AdvSimd.Min")] + [InlineData("short", "AdvSimd.Max")] + [InlineData("short", "AdvSimd.Min")] + [InlineData("ushort", "AdvSimd.Max")] + [InlineData("ushort", "AdvSimd.Min")] + [InlineData("int", "AdvSimd.Max")] + [InlineData("int", "AdvSimd.Min")] + [InlineData("uint", "AdvSimd.Max")] + [InlineData("uint", "AdvSimd.Min")] + [InlineData("float", "AdvSimd.Max")] + [InlineData("float", "AdvSimd.Min")] + public async Task Fixer_MinMaxAdvSimdAsync(string type, string method) + { + var ruleKind = method.Contains("Max") ? RuleKind.Max : RuleKind.Min; + var expectedMethod = method.Contains("Max") ? "Max" : "Min"; + + // lang=C#-test + string testCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Arm; + + class C + { + Vector64<{{type}}> M(Vector64<{{type}}> x, Vector64<{{type}}> y) => {|#1:{{method}}(x, y)|}; + } + """; + + // lang=C#-test + string fixedCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Arm; + + class C + { + Vector64<{{type}}> M(Vector64<{{type}}> x, Vector64<{{type}}> y) => Vector64.{{expectedMethod}}(x, y); + } + """; + + await new VerifyCS.Test + { + TestCode = testCode, + ExpectedDiagnostics = { + VerifyCS.Diagnostic(Rules[(int)ruleKind]).WithLocation(1), + }, + FixedCode = fixedCode, + ReferenceAssemblies = ReferenceAssemblies.Net.Net80 + }.RunAsync(); + } + } +} diff --git a/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.Sqrt.cs b/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.Sqrt.cs new file mode 100644 index 000000000000..d064a1265f70 --- /dev/null +++ b/src/Microsoft.CodeAnalysis.NetAnalyzers/tests/Microsoft.CodeAnalysis.NetAnalyzers.UnitTests/Microsoft.CodeQuality.Analyzers/Maintainability/CSharpUseCrossPlatformIntrinsicsTests.Sqrt.cs @@ -0,0 +1,135 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the MIT license. See License.txt in the project root for license information. + +using System.Threading.Tasks; +using Microsoft.CodeAnalysis.Testing; +using Xunit; +using VerifyCS = Test.Utilities.CSharpCodeFixVerifier< + Microsoft.CodeQuality.CSharp.Analyzers.Maintainability.CSharpUseCrossPlatformIntrinsicsAnalyzer, + Microsoft.CodeQuality.CSharp.Analyzers.Maintainability.CSharpUseCrossPlatformIntrinsicsFixer>; + +namespace Microsoft.CodeQuality.Analyzers.Maintainability.UnitTests +{ + using static UseCrossPlatformIntrinsicsAnalyzer; + + public partial class CSharpUseCrossPlatformIntrinsicsTests + { + [Theory] + [InlineData("float", "Sse.Sqrt")] + [InlineData("double", "Sse2.Sqrt")] + public async Task Fixer_SqrtSseAsync(string type, string method) + { + // lang=C#-test + string testCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.X86; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x) => {|#1:{{method}}(x)|}; + } + """; + + // lang=C#-test + string fixedCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.X86; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x) => Vector128.Sqrt(x); + } + """; + + await new VerifyCS.Test + { + TestCode = testCode, + ExpectedDiagnostics = { + VerifyCS.Diagnostic(Rules[(int)RuleKind.Sqrt]).WithLocation(1), + }, + FixedCode = fixedCode, + ReferenceAssemblies = ReferenceAssemblies.Net.Net80 + }.RunAsync(); + } + + [Theory] + [InlineData("float", "PackedSimd.Sqrt")] + public async Task Fixer_SqrtWasmAsync(string type, string method) + { + // lang=C#-test + string testCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Wasm; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x) => {|#1:{{method}}(x)|}; + } + """; + + // lang=C#-test + string fixedCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.Wasm; + + class C + { + Vector128<{{type}}> M(Vector128<{{type}}> x) => Vector128.Sqrt(x); + } + """; + + await new VerifyCS.Test + { + TestCode = testCode, + ExpectedDiagnostics = { + VerifyCS.Diagnostic(Rules[(int)RuleKind.Sqrt]).WithLocation(1), + }, + FixedCode = fixedCode, + ReferenceAssemblies = ReferenceAssemblies.Net.Net80 + }.RunAsync(); + } + + [Theory] + [InlineData("float", "Avx.Sqrt")] + [InlineData("double", "Avx.Sqrt")] + public async Task Fixer_SqrtAvxAsync(string type, string method) + { + // lang=C#-test + string testCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.X86; + + class C + { + Vector256<{{type}}> M(Vector256<{{type}}> x) => {|#1:{{method}}(x)|}; + } + """; + + // lang=C#-test + string fixedCode = $$""" + using System; + using System.Runtime.Intrinsics; + using System.Runtime.Intrinsics.X86; + + class C + { + Vector256<{{type}}> M(Vector256<{{type}}> x) => Vector256.Sqrt(x); + } + """; + + await new VerifyCS.Test + { + TestCode = testCode, + ExpectedDiagnostics = { + VerifyCS.Diagnostic(Rules[(int)RuleKind.Sqrt]).WithLocation(1), + }, + FixedCode = fixedCode, + ReferenceAssemblies = ReferenceAssemblies.Net.Net80 + }.RunAsync(); + } + } +}