Unify HasAttribute and HasAnyAttribute

dotnet · Jul 31, 2023 · d2a70fe · d2a70fe
1 parent f57fa2c
commit d2a70fe
Show file tree

Hide file tree

Showing 42 changed files with 89 additions and 94 deletions.
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/ClassIsNotDiagnosticAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/ClassIsNotDiagnosticAnalyzer.cs
@@ -47,7 +47,7 @@ public override void Initialize(AnalysisContext context)
                     var namedType = (INamedTypeSymbol)sac.Symbol;
 
                     if (namedType.TypeKind == TypeKind.Class &&
-                        namedType.HasAttribute(diagnosticAnalyzerAttribute) &&
+                        namedType.HasAnyAttribute(diagnosticAnalyzerAttribute) &&
                         !namedType.DerivesFrom(diagnosticAnalyzer, baseTypesOnly: true))
                     {
                         sac.ReportDiagnostic(namedType.Locations[0].CreateDiagnostic(Rule, namedType.Name));

diff --git a/...tAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/AvoidOutParameters.cs b/...tAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/AvoidOutParameters.cs
@@ -79,7 +79,7 @@ public void Analyze(SymbolAnalysisContext analysisContext)
             private bool IsOutParameter(IParameterSymbol parameterSymbol) =>
                 parameterSymbol.RefKind == RefKind.Out ||
                 // Handle VB.NET special case for out parameters
-                (parameterSymbol.RefKind == RefKind.Ref && parameterSymbol.HasAttribute(outAttributeSymbol));
+                (parameterSymbol.RefKind == RefKind.Ref && parameterSymbol.HasAnyAttribute(outAttributeSymbol));
 
             private bool IsTryPatternMethod(IMethodSymbol methodSymbol, int numberOfOutParams) =>
                 methodSymbol.Name.StartsWith("Try", StringComparison.Ordinal) &&

diff --git a/...crosoft.CodeQuality.Analyzers/ApiDesignGuidelines/CollectionPropertiesShouldBeReadOnly.cs b/...crosoft.CodeQuality.Analyzers/ApiDesignGuidelines/CollectionPropertiesShouldBeReadOnly.cs
@@ -125,7 +125,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, KnownTypes know
             }
 
             // Special case: the DataContractSerializer requires that a public setter exists.
-            if (property.HasAttribute(knownTypes.DataMemberAttribute))
+            if (property.HasAnyAttribute(knownTypes.DataMemberAttribute))
             {
                 return;
             }

diff --git a/.../Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/DoNotDeclareVisibleInstanceFields.cs b/.../Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/DoNotDeclareVisibleInstanceFields.cs
@@ -54,7 +54,7 @@ public override void Initialize(AnalysisContext context)
 
                     // Do not report on types marked with StructLayoutAttribute
                     // See https://github.com/dotnet/roslyn-analyzers/issues/4149
-                    if (field.ContainingType.HasAttribute(structLayoutAttributeType))
+                    if (field.ContainingType.HasAnyAttribute(structLayoutAttributeType))
                     {
                         return;
                     }

diff --git a/...ers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/DoNotPassTypesByReference.cs b/...ers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/DoNotPassTypesByReference.cs
@@ -60,7 +60,7 @@ public override void Initialize(AnalysisContext context)
                     {
                         // VB.NET out is a ref parameter with the OutAttribute
                         if (parameterSymbol.RefKind == RefKind.Ref &&
-                            !parameterSymbol.HasAttribute(outAttributeType))
+                            !parameterSymbol.HasAnyAttribute(outAttributeType))
                         {
                             context.ReportDiagnostic(parameterSymbol.CreateDiagnostic(Rule, parameterSymbol.Name));
                         }

diff --git a/...zers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EnumStorageShouldBeInt32.cs b/...zers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EnumStorageShouldBeInt32.cs
@@ -72,7 +72,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo
             }
 
             // If enum is Int64 and has Flags attributes then exit
-            if (underlyingType == SpecialType.System_Int64 && symbol.HasAttribute(flagsAttribute))
+            if (underlyingType == SpecialType.System_Int64 && symbol.HasAnyAttribute(flagsAttribute))
             {
                 return;
             }

diff --git a/...lyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EnumWithFlagsAttribute.cs b/...lyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EnumWithFlagsAttribute.cs
@@ -94,7 +94,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext symbolContext, INamedTyp
 
                 if (EnumHelpers.TryGetEnumMemberValues(symbol, out IList<ulong> memberValues))
                 {
-                    if (symbol.HasAttribute(flagsAttributeType))
+                    if (symbol.HasAnyAttribute(flagsAttributeType))
                     {
                         // Check "CA2217: Do not mark enums with FlagsAttribute"
                         if (reportCA2217 && !ShouldBeFlags(memberValues, out IEnumerable<ulong> missingValues))

diff --git a/...zers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EnumsShouldHaveZeroValue.cs b/...zers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/EnumsShouldHaveZeroValue.cs
@@ -117,7 +117,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo
 
             ImmutableArray<IFieldSymbol> zeroValuedFields = GetZeroValuedFields(symbol).ToImmutableArray();
 
-            if (symbol.HasAttribute(flagsAttribute))
+            if (symbol.HasAnyAttribute(flagsAttribute))
             {
                 CheckFlags(symbol, zeroValuedFields, context);
             }

diff --git a/...e/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/MarkAttributesWithAttributeUsage.cs b/...e/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/MarkAttributesWithAttributeUsage.cs
@@ -65,7 +65,7 @@ private static void AnalyzeSymbol<TContext>(INamedTypeSymbol symbol, INamedTypeS
                 return;
             }
 
-            if (!symbol.HasAttribute(attributeUsageAttributeType))
+            if (!symbol.HasAnyAttribute(attributeUsageAttributeType))
             {
                 addDiagnostic(context, symbol.CreateDiagnostic(Rule, symbol.Name));
             }

diff --git a/...rosoft.CodeQuality.Analyzers/ApiDesignGuidelines/PropertyNamesShouldNotMatchGetMethods.cs b/...rosoft.CodeQuality.Analyzers/ApiDesignGuidelines/PropertyNamesShouldNotMatchGetMethods.cs
@@ -72,7 +72,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo
 
             // If either the property or method is marked as obsolete, bail out
             // see https://github.com/dotnet/roslyn-analyzers/issues/2956
-            if (symbol.HasAttribute(obsoleteAttributeType))
+            if (symbol.HasAnyAttribute(obsoleteAttributeType))
             {
                 return;
             }
@@ -116,7 +116,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo
 
                     // If either the property or method is marked as obsolete, bail out
                     // see https://github.com/dotnet/roslyn-analyzers/issues/2956
-                    if (member.HasAttribute(obsoleteAttributeType))
+                    if (member.HasAnyAttribute(obsoleteAttributeType))
                     {
                         continue;
                     }

diff --git a/...re/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UseGenericEventHandlerInstances.cs b/...re/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/UseGenericEventHandlerInstances.cs
@@ -99,7 +99,7 @@ static bool IsDelegateTypeWithInvokeMethod(INamedTypeSymbol namedType) =>
                     INamedTypeSymbol? comSourceInterfacesAttribute = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeInteropServicesComSourceInterfacesAttribute);
                     bool ContainingTypeHasComSourceInterfacesAttribute(IEventSymbol eventSymbol) =>
                         comSourceInterfacesAttribute != null &&
-                        eventSymbol.ContainingType.HasAttribute(comSourceInterfacesAttribute);
+                        eventSymbol.ContainingType.HasAnyAttribute(comSourceInterfacesAttribute);
 
                     context.RegisterSymbolAction(symbolContext =>
                     {

diff --git a/...ore/Microsoft.CodeQuality.Analyzers/Maintainability/AvoidUninstantiatedInternalClasses.cs b/...ore/Microsoft.CodeQuality.Analyzers/Maintainability/AvoidUninstantiatedInternalClasses.cs
@@ -50,7 +50,7 @@ public sealed override void Initialize(AnalysisContext context)
                 var compilation = startContext.Compilation;
                 var entryPointContainingType = compilation.GetEntryPoint(startContext.CancellationToken)?.ContainingType;
                 var wellKnownTypeProvider = WellKnownTypeProvider.GetOrCreate(compilation);
-                var hasInternalsVisibleTo = startContext.Compilation.Assembly.HasAttribute(
+                var hasInternalsVisibleTo = startContext.Compilation.Assembly.HasAnyAttribute(
                     startContext.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeCompilerServicesInternalsVisibleToAttribute));
 
                 var systemAttributeSymbol = wellKnownTypeProvider.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemAttribute);
@@ -349,8 +349,8 @@ public static bool IsMefExported(
             INamedTypeSymbol? mef1ExportAttributeSymbol,
             INamedTypeSymbol? mef2ExportAttributeSymbol)
         {
-            return (mef1ExportAttributeSymbol != null && type.HasAttribute(mef1ExportAttributeSymbol))
-                || (mef2ExportAttributeSymbol != null && type.HasAttribute(mef2ExportAttributeSymbol));
+            return (mef1ExportAttributeSymbol != null && type.HasAnyAttribute(mef1ExportAttributeSymbol))
+                || (mef2ExportAttributeSymbol != null && type.HasAnyAttribute(mef2ExportAttributeSymbol));
         }
 
         /// <summary>

diff --git a/...nalyzers/Core/Microsoft.CodeQuality.Analyzers/Maintainability/DoNotIgnoreMethodResults.cs b/...nalyzers/Core/Microsoft.CodeQuality.Analyzers/Maintainability/DoNotIgnoreMethodResults.cs
@@ -307,7 +307,7 @@ bool IsXunitThrowsArgument(IParameterSymbol parameterSymbol)
 
                 IMethodSymbol methodSymbol = (IMethodSymbol)operationContext.ContainingSymbol;
 
-                return methodSymbol.HasAttribute(expectedExceptionType);
+                return methodSymbol.HasAnyAttribute(expectedExceptionType);
             }
             else
             {
@@ -346,7 +346,7 @@ private static bool IsHResultOrErrorCodeReturningMethod(IMethodSymbol method)
 
         private static bool IsPureMethod(IMethodSymbol method, Compilation compilation)
         {
-            return method.HasAttribute(compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemDiagnosticsContractsPureAttribute));
+            return method.HasAnyAttribute(compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemDiagnosticsContractsPureAttribute));
         }
     }
 }
diff --git a/...etAnalyzers/Core/Microsoft.CodeQuality.Analyzers/QualityGuidelines/MarkMembersAsStatic.cs b/...etAnalyzers/Core/Microsoft.CodeQuality.Analyzers/QualityGuidelines/MarkMembersAsStatic.cs
@@ -319,8 +319,8 @@ private static bool IsExplicitlyVisibleFromCom(IMethodSymbol methodSymbol, WellK
                 return false;
             }
 
-            if (methodSymbol.HasAttribute(comVisibleAttribute) ||
-                methodSymbol.ContainingType.HasAttribute(comVisibleAttribute))
+            if (methodSymbol.HasAnyAttribute(comVisibleAttribute) ||
+                methodSymbol.ContainingType.HasAnyAttribute(comVisibleAttribute))
             {
                 return true;
             }
@@ -371,7 +371,7 @@ private static bool IsOnObsoleteMemberChain(ISymbol symbol, WellKnownTypeProvide
 
             while (symbol != null)
             {
-                if (symbol.HasAttribute(obsoleteAttributeType))
+                if (symbol.HasAnyAttribute(obsoleteAttributeType))
                     return true;
 
                 symbol = symbol is IMethodSymbol method && method.AssociatedSymbol != null

diff --git a/...Analyzers/Core/Microsoft.CodeQuality.Analyzers/QualityGuidelines/RemoveEmptyFinalizers.cs b/...Analyzers/Core/Microsoft.CodeQuality.Analyzers/QualityGuidelines/RemoveEmptyFinalizers.cs
@@ -73,7 +73,7 @@ private static bool CanDescendIntoOperation(IOperation operation, INamedTypeSymb
             if (operation.Kind == OperationKind.Invocation)
             {
                 return isMethodSurroundedWithDirective
-                    || !((IInvocationOperation)operation).TargetMethod.HasAttribute(conditionalAttributeType);
+                    || !((IInvocationOperation)operation).TargetMethod.HasAnyAttribute(conditionalAttributeType);
             }
 
             return true;

diff --git a/...etAnalyzers/Core/Microsoft.NetCore.Analyzers/InteropServices/DisableRuntimeMarshalling.cs b/...etAnalyzers/Core/Microsoft.NetCore.Analyzers/InteropServices/DisableRuntimeMarshalling.cs
@@ -147,7 +147,7 @@ public override void Initialize(AnalysisContext context)
                     out INamedTypeSymbol? disableRuntimeMarshallingAttribute))
                 {
                     AutoLayoutTypeCache autoLayoutCache = new(context.Compilation);
-                    var hasDisableRuntimeMarshallingAttribute = context.Compilation.Assembly.HasAttribute(disableRuntimeMarshallingAttribute);
+                    var hasDisableRuntimeMarshallingAttribute = context.Compilation.Assembly.HasAnyAttribute(disableRuntimeMarshallingAttribute);
                     if (hasDisableRuntimeMarshallingAttribute)
                     {
                         var disabledRuntimeMarshallingAssemblyAnalyzer = new DisabledRuntimeMarshallingAssemblyAnalyzer(context.Compilation, autoLayoutCache);

diff --git a/...alyzers/InteropServices/DisableRuntimeMarshallingAnalyzer.DelegateInteropUsageAnalyzer.cs b/...alyzers/InteropServices/DisableRuntimeMarshallingAnalyzer.DelegateInteropUsageAnalyzer.cs
@@ -90,7 +90,7 @@ private void AnalyzeInvocation(OperationAnalysisContext context)
 
                 void AnalyzeDelegateType(OperationAnalysisContext context, IOperation operation, INamedTypeSymbol delegateType)
                 {
-                    if (delegateType.ContainingAssembly.HasAttribute(_disableRuntimeMarshallingAttribute))
+                    if (delegateType.ContainingAssembly.HasAnyAttribute(_disableRuntimeMarshallingAttribute))
                     {
                         AnalyzeMethodSignature(_autoLayoutCache, context.ReportDiagnostic, delegateType.DelegateInvokeMethod!, ImmutableArray.Create(operation.Syntax.GetLocation()), FeatureUnsupportedWhenRuntimeMarshallingDisabledDelegateUsage);
                     }
@@ -137,7 +137,7 @@ private void AnalyzeMethod(Action<Diagnostic> reportDiagnostic, IMethodSymbol sy
 
                 void AnalyzeDelegateMethodSignature(INamedTypeSymbol delegateType, ISymbol signatureSymbol)
                 {
-                    if (delegateType.ContainingAssembly.HasAttribute(_disableRuntimeMarshallingAttribute))
+                    if (delegateType.ContainingAssembly.HasAnyAttribute(_disableRuntimeMarshallingAttribute))
                     {
                         AnalyzeMethodSignature(_autoLayoutCache, reportDiagnostic, delegateType.DelegateInvokeMethod!, signatureSymbol.Locations, FeatureUnsupportedWhenRuntimeMarshallingDisabledDelegateUsage);
                     }

diff --git a/...pServices/DisableRuntimeMarshallingAnalyzer.DisabledRuntimeMarshallingAssemblyAnalyzer.cs b/...pServices/DisableRuntimeMarshallingAnalyzer.DisabledRuntimeMarshallingAssemblyAnalyzer.cs
@@ -118,7 +118,7 @@ public void AnalyzeType(SymbolAnalysisContext context)
             {
                 Debug.Assert(_unmanagedFunctionPointerAttribute is not null);
                 INamedTypeSymbol type = (INamedTypeSymbol)context.Symbol;
-                if (type.TypeKind != TypeKind.Delegate || !type.HasAttribute(_unmanagedFunctionPointerAttribute))
+                if (type.TypeKind != TypeKind.Delegate || !type.HasAnyAttribute(_unmanagedFunctionPointerAttribute))
                 {
                     return;
                 }
@@ -152,7 +152,7 @@ private void AnalyzeMethod(Action<Diagnostic> reportDiagnostic, IMethodSymbol me
                     reportDiagnostic(method.CreateDiagnostic(FeatureUnsupportedWhenRuntimeMarshallingDisabledHResultSwapping));
                 }
 
-                if (method.HasAttribute(_lcidConversionAttribute))
+                if (method.HasAnyAttribute(_lcidConversionAttribute))
                 {
                     reportDiagnostic(method.CreateDiagnostic(FeatureUnsupportedWhenRuntimeMarshallingDisabledUsingLCIDConversionAttribute));
                 }

diff --git a/...icrosoft.NetCore.Analyzers/InteropServices/DoNotUseOutAttributeStringPInvokeParameters.cs b/...icrosoft.NetCore.Analyzers/InteropServices/DoNotUseOutAttributeStringPInvokeParameters.cs
@@ -60,7 +60,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo
             {
                 if (parameter.Type.SpecialType == SpecialType.System_String
                     && parameter.RefKind == RefKind.None
-                    && parameter.HasAttribute(outAttributeType))
+                    && parameter.HasAnyAttribute(outAttributeType))
                 {
                     context.ReportDiagnostic(parameter.CreateDiagnostic(Rule, parameter.Name));
                 }

diff --git a/...ore/Microsoft.NetCore.Analyzers/InteropServices/DynamicInterfaceCastableImplementation.cs b/...ore/Microsoft.NetCore.Analyzers/InteropServices/DynamicInterfaceCastableImplementation.cs
@@ -86,7 +86,7 @@ private static void AnalyzeType(SymbolAnalysisContext context, INamedTypeSymbol
                 return;
             }
 
-            if (!targetType.HasAttribute(dynamicInterfaceCastableImplementationAttribute))
+            if (!targetType.HasAnyAttribute(dynamicInterfaceCastableImplementationAttribute))
             {
                 return;
             }

diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Performance/ConstantExpectedAnalyzer.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Performance/ConstantExpectedAnalyzer.cs
@@ -433,7 +433,7 @@ public bool TryGetConstantExpectedAttributeData([NotNullWhen(true)] IParameterSy
 
             private bool HasConstantExpectedAttributeData(IParameterSymbol parameter)
             {
-                return parameter.HasAttribute(AttributeSymbol);
+                return parameter.HasAnyAttribute(AttributeSymbol);
             }
 
             public static bool TryCreate(Compilation compilation, [NotNullWhen(true)] out ConstantExpectedContext? constantExpectedContext)

diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DetectPreviewFeatureAnalyzer.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DetectPreviewFeatureAnalyzer.cs
@@ -234,7 +234,7 @@ public override void Initialize(AnalysisContext context)
                     return;
                 }
 
-                if (context.Compilation.Assembly.HasAttribute(previewFeaturesAttribute))
+                if (context.Compilation.Assembly.HasAnyAttribute(previewFeaturesAttribute))
                 {
                     // This assembly has enabled preview attributes.
                     return;

diff --git a/...lyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DoNotPassLiteralsAsLocalizedParameters.cs b/...lyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DoNotPassLiteralsAsLocalizedParameters.cs
@@ -247,7 +247,7 @@ private static bool ShouldBeLocalized(
 
             // FxCop compat checks.
             if (typesToIgnore.Contains(parameterSymbol.ContainingType) ||
-                parameterSymbol.ContainingSymbol.HasAttribute(conditionalAttributeSymbol))
+                parameterSymbol.ContainingSymbol.HasAnyAttribute(conditionalAttributeSymbol))
             {
                 return false;
             }

diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SealInternalTypes.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SealInternalTypes.cs
@@ -43,7 +43,7 @@ private static void OnCompilationStart(CompilationStartAnalysisContext context)
 
             var candidateTypes = PooledConcurrentSet<INamedTypeSymbol>.GetInstance(SymbolEqualityComparer.Default);
             var baseTypes = PooledConcurrentSet<INamedTypeSymbol>.GetInstance(SymbolEqualityComparer.Default);
-            var hasInternalsVisibleTo = context.Compilation.Assembly.HasAttribute(
+            var hasInternalsVisibleTo = context.Compilation.Assembly.HasAnyAttribute(
                 context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeCompilerServicesInternalsVisibleToAttribute));
 
             context.RegisterSymbolAction(context =>
@@ -55,7 +55,7 @@ private static void OnCompilationStart(CompilationStartAnalysisContext context)
                     !type.IsStatic &&
                     !type.IsSealed &&
                     !type.IsExternallyVisible() &&
-                    !type.HasAttribute(comImportAttributeType) &&
+                    !type.HasAnyAttribute(comImportAttributeType) &&
                     !type.IsTopLevelStatementsEntryPointType())
                 {
                     candidateTypes.Add(type);

diff --git a/...nalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SerializationRulesDiagnosticAnalyzer.cs b/...nalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/SerializationRulesDiagnosticAnalyzer.cs
@@ -239,7 +239,7 @@ public void AnalyzeSymbol(SymbolAnalysisContext context)
                         }
 
                         // Check for [NonSerialized]
-                        if (field.HasAttribute(_nonSerializedAttributeTypeSymbol))
+                        if (field.HasAnyAttribute(_nonSerializedAttributeTypeSymbol))
                         {
                             continue;
                         }
@@ -276,7 +276,7 @@ private bool IsSerializable(ITypeSymbol type)
                     TypeKind.Class or TypeKind.Struct => ((INamedTypeSymbol)type).IsSerializable,// Check SerializableAttribute or Serializable flag from metadata.
                     TypeKind.Delegate => true,// delegates are always serializable, even if
                                               // they aren't actually marked [Serializable]
-                    _ => type.HasAttribute(_serializableAttributeTypeSymbol),
+                    _ => type.HasAnyAttribute(_serializableAttributeTypeSymbol),
                 };
             }
         }

diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/UseAsyncMethodInAsyncContext.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/UseAsyncMethodInAsyncContext.cs
@@ -118,7 +118,7 @@ public override void Initialize(AnalysisContext context)
 
                                 foreach (IMethodSymbol method in methodSymbols)
                                 {
-                                    if (!method.HasAttribute(systemObsoleteAttribute)
+                                    if (!method.HasAnyAttribute(systemObsoleteAttribute)
                                         && HasSupersetOfParameterTypes(method, methodSymbol)
                                         && method.Name != containingMethodName
                                         && HasAsyncCompatibleReturnType(method, syncBlockingTypes))
@@ -234,7 +234,7 @@ static bool CheckReturnTypeMatch(string targetType, ISymbol returnType, Concurre
                 || CheckReturnTypeMatch("ValueTask", returnType, syncBlockingTypes)
                 || CheckReturnTypeMatch("IAsyncEnumerableGeneric", returnType, syncBlockingTypes)
                 || (syncBlockingTypes.TryGetValue("AsyncMethodBuilderAttribute", out INamedTypeSymbol? asyncMethodBuilderAttributeTypeValue)
-                && returnType.HasAttribute(asyncMethodBuilderAttributeTypeValue));
+                && returnType.HasAnyAttribute(asyncMethodBuilderAttributeTypeValue));
         }
 
         private static IMethodSymbol? GetParentMethodOrDelegate(OperationAnalysisContext context)

diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/UseThreadStaticCorrectly.cs b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/UseThreadStaticCorrectly.cs
@@ -76,7 +76,7 @@ public override void Initialize(AnalysisContext context)
                     }
 
                     // Once we have the field, see if it's attributed with [ThreadStatic].
-                    if (fieldSymbol?.HasAttribute(threadStaticAttributeType) == true)
+                    if (fieldSymbol?.HasAnyAttribute(threadStaticAttributeType) == true)
                     {
                         context.ReportDiagnostic(symbol.CreateDiagnostic(ThreadStaticOnNonStaticFieldRule));
                     }
@@ -88,7 +88,7 @@ public override void Initialize(AnalysisContext context)
                     var fieldInit = (IFieldInitializerOperation)context.Operation;
                     foreach (IFieldSymbol field in fieldInit.InitializedFields)
                     {
-                        if (field.IsStatic && field.HasAttribute(threadStaticAttributeType))
+                        if (field.IsStatic && field.HasAnyAttribute(threadStaticAttributeType))
                         {
                             context.ReportDiagnostic(fieldInit.CreateDiagnostic(ThreadStaticInitializedInlineRule));
                             break;
-Original file line number
+Diff line change
@@ Expand Up @@
                 }
                 // Special case: the DataContractSerializer requires that a public setter exists.
-                if (property.HasAttribute(knownTypes.DataMemberAttribute))
+                if (property.HasAnyAttribute(knownTypes.DataMemberAttribute))
                 {
                     return;
                 }
@@ Expand Down @@