Filter IntelliSense attribute suggestions by AttributeTargets

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SymbolCompletionProviderTests.cs

@@ -447,6 +447,124 @@ await VerifyExpectedItemsAsync(code, [
         ]);
     }
 
+    [Fact]
+    public async Task AttributeTargetFiltering_AssemblyAttribute()
+    {
+        var code = """
+            [assembly: $$]
+
+            namespace TestNamespace
+            {
+                class Program
+                {
+                    static void Main(string[] args)
+                    {
+                    }
+                }
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.Assembly)]
+            public class AssemblyOnlyAttribute : System.Attribute
+            {
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.Class)]
+            public class ClassOnlyAttribute : System.Attribute
+            {
+            }
+            """;
+
+        await VerifyExpectedItemsAsync(code, [
+            ItemExpectation.Exists("AssemblyOnly"),
+            ItemExpectation.Absent("ClassOnly")
+        ]);
+    }
+
+    [Fact]
+    public async Task AttributeTargetFiltering_ClassAttribute()
+    {
+        var code = """
+            [$$]
+            class TestClass
+            {
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.Assembly)]
+            public class AssemblyOnlyAttribute : System.Attribute
+            {
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.Class)]
+            public class ClassOnlyAttribute : System.Attribute
+            {
+            }
+            """;
+
+        await VerifyExpectedItemsAsync(code, [
+            ItemExpectation.Absent("AssemblyOnly"),
+            ItemExpectation.Exists("ClassOnly")
+        ]);
+    }
+
+    [Fact]
+    public async Task AttributeTargetFiltering_MethodAttribute()
+    {
+        var code = """
+            class TestClass
+            {
+                [$$]
+                void TestMethod()
+                {
+                }
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.Method)]
+            public class MethodOnlyAttribute : System.Attribute
+            {
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.Property)]
+            public class PropertyOnlyAttribute : System.Attribute
+            {
+            }
+            """;
+
+        await VerifyExpectedItemsAsync(code, [
+            ItemExpectation.Exists("MethodOnly"),
+            ItemExpectation.Absent("PropertyOnly")
+        ]);
+    }
+
+    [Fact]
+    public async Task AttributeTargetFiltering_ExplicitTargetSpecifier()
+    {
+        var code = """
+            class TestClass
+            {
+                [return: $$]
+                int TestMethod()
+                {
+                    return 0;
+                }
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.ReturnValue)]
+            public class ReturnValueOnlyAttribute : System.Attribute
+            {
+            }
+
+            [System.AttributeUsage(System.AttributeTargets.Method)]
+            public class MethodOnlyAttribute : System.Attribute
+            {
+            }
+            """;
+
+        await VerifyExpectedItemsAsync(code, [
+            ItemExpectation.Exists("ReturnValueOnly"),
+            ItemExpectation.Absent("MethodOnly")
+        ]);
+    }
+
     [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/7213")]
     public Task NamespaceName_EmptyNameSpan_TopLevel()
         => VerifyItemExistsAsync(@"namespace $$ { }", "System", sourceCodeKind: SourceCodeKind.Regular);

src/Workspaces/Core/Portable/Recommendations/AbstractRecommendationService.cs

@@ -108,6 +108,7 @@ internal bool ShouldIncludeSymbol(ISymbol symbol)
                 return symbol.IsOrContainsAccessibleAttribute(
                     _context.SemanticModel.GetEnclosingNamedType(_context.LeftToken.SpanStart, _cancellationToken)!,
                     _context.SemanticModel.Compilation.Assembly,
+                    _context.ValidAttributeTargets,
                     _cancellationToken);
             }
 

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Extensions/Symbols/ISymbolExtensions.cs

@@ -536,6 +536,10 @@ public static bool IsStaticType([NotNullWhen(true)] this ISymbol? symbol)
 
     public static bool IsOrContainsAccessibleAttribute(
         [NotNullWhen(true)] this ISymbol? symbol, ISymbol withinType, IAssemblySymbol withinAssembly, CancellationToken cancellationToken)
+        => IsOrContainsAccessibleAttribute(symbol, withinType, withinAssembly, AttributeTargets.All, cancellationToken);
+
+    public static bool IsOrContainsAccessibleAttribute(
+        [NotNullWhen(true)] this ISymbol? symbol, ISymbol withinType, IAssemblySymbol withinAssembly, AttributeTargets validTargets, CancellationToken cancellationToken)
     {
         var namespaceOrType = symbol is IAliasSymbol alias ? alias.Target : symbol as INamespaceOrTypeSymbol;
         if (namespaceOrType == null)
@@ -548,13 +552,49 @@ public static bool IsOrContainsAccessibleAttribute(
         {
             if (type.IsAttribute() && type.IsAccessibleWithin(withinType ?? withinAssembly))
             {
+                // Check if the attribute is valid for the specified targets
+                if (validTargets != AttributeTargets.All && !IsAttributeValidForTargets(type, validTargets))
+                {
+                    continue;
+                }
+
                 return true;
             }
         }
 
         return false;
     }
 
+    private static bool IsAttributeValidForTargets(INamedTypeSymbol attributeType, AttributeTargets validTargets)
+    {
+        // Get the AttributeUsageAttribute applied to this attribute type
+        var attributeUsageAttribute = attributeType.GetAttributes()
+            .FirstOrDefault(attr => attr.AttributeClass?.Name == "AttributeUsageAttribute" &&
+                                   attr.AttributeClass.ContainingNamespace?.Name == "System" &&
+                                   attr.AttributeClass.ContainingNamespace.ContainingNamespace?.IsGlobalNamespace == true);
+
+        if (attributeUsageAttribute == null)
+        {
+            // If no AttributeUsage is specified, the default is AttributeTargets.All
+            return true;
+        }
+
+        // The first constructor argument is the AttributeTargets value
+        if (attributeUsageAttribute.ConstructorArguments.Length > 0)
+        {
+            var constructorArg = attributeUsageAttribute.ConstructorArguments[0];
+            if (constructorArg.Value is int targetsValue)
+            {
+                var attributeTargets = (AttributeTargets)targetsValue;
+                // Check if there's any overlap between the attribute's targets and the valid targets
+                return (attributeTargets & validTargets) != 0;
+            }
+        }
+
+        // Default to allowing the attribute if we can't determine the targets
+        return true;
+    }
+
     public static IEnumerable<IPropertySymbol> GetValidAnonymousTypeProperties(this ISymbol symbol)
     {
         Contract.ThrowIfFalse(symbol.IsNormalAnonymousType());

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/CSharpSyntaxContext.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
@@ -177,6 +178,8 @@
         this.PrecedingModifiers = precedingModifiers;
     }
 
+    public override AttributeTargets ValidAttributeTargets => ComputeValidAttributeTargets();
+
     public static CSharpSyntaxContext CreateContext(Document document, SemanticModel semanticModel, int position, CancellationToken cancellationToken)
         => CreateContextWorker(document, semanticModel, position, cancellationToken);
 
@@ -512,4 +515,75 @@
 
         return false;
     }
+
+    private AttributeTargets ComputeValidAttributeTargets()
+    {
+        // If we're not in an attribute context, return All to allow all attributes
+        if (!IsAttributeNameContext)
+            return AttributeTargets.All;
+
+        // Find the attribute list that contains the current position
+        var token = TargetToken;
+        var attributeList = token.Parent?.FirstAncestorOrSelf<AttributeListSyntax>();
+        if (attributeList == null)
+            return AttributeTargets.All;
+
+        // Check if there's an explicit target specifier (e.g., "assembly:", "return:", etc.)
+        if (attributeList.Target != null)
+        {
+            var targetIdentifier = attributeList.Target.Identifier.ValueText;
+            return targetIdentifier switch
+            {
+                "assembly" or "module" => AttributeTargets.Assembly | AttributeTargets.Module,
+                "type" => AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate,
+                "method" => AttributeTargets.Method,
+                "field" => AttributeTargets.Field,
+                "property" => AttributeTargets.Property,
+                "event" => AttributeTargets.Event,
+                "param" => AttributeTargets.Parameter,
+                "return" => AttributeTargets.ReturnValue,
+                "typevar" => AttributeTargets.GenericParameter,
+                _ => AttributeTargets.All
+            };
+        }
+
+        // No explicit target, determine from context
+        // Walk up to find what the attribute is attached to
+        var parentNode = attributeList.Parent;
+        if (parentNode == null)
+            return AttributeTargets.All;
+
+        return parentNode switch
+        {
+            // Type declarations
+            ClassDeclarationSyntax => AttributeTargets.Class,
+            StructDeclarationSyntax => AttributeTargets.Struct,
+            InterfaceDeclarationSyntax => AttributeTargets.Interface,
+            EnumDeclarationSyntax => AttributeTargets.Enum,
+            DelegateDeclarationSyntax => AttributeTargets.Delegate,
+            RecordDeclarationSyntax record => record.ClassOrStructKeyword.IsKind(SyntaxKind.StructKeyword) 
+                ? AttributeTargets.Struct 
+                : AttributeTargets.Class,
+
+            // Member declarations
+            MethodDeclarationSyntax => AttributeTargets.Method,
+            ConstructorDeclarationSyntax => AttributeTargets.Constructor,
+            PropertyDeclarationSyntax => AttributeTargets.Property,
+            EventDeclarationSyntax => AttributeTargets.Event,
+            EventFieldDeclarationSyntax => AttributeTargets.Event,
+            FieldDeclarationSyntax => AttributeTargets.Field,
+            IndexerDeclarationSyntax => AttributeTargets.Property,
+
+            // Parameters
+            ParameterSyntax => AttributeTargets.Parameter,
+
+            // Type parameters
+            TypeParameterSyntax => AttributeTargets.GenericParameter,
+
+            // Assembly/module level
+            CompilationUnitSyntax => AttributeTargets.Assembly | AttributeTargets.Module,
+
+            _ => AttributeTargets.All
+        };
+    }
 }

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ContextQuery/SyntaxContext.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Immutable;
 using System.Threading;
 using Microsoft.CodeAnalysis.Host;
@@ -96,6 +97,13 @@ internal abstract class SyntaxContext(
 
     public ImmutableArray<ITypeSymbol> InferredTypes { get; } = document.GetRequiredLanguageService<ITypeInferenceService>().InferTypes(semanticModel, position, cancellationToken);
 
+    /// <summary>
+    /// Gets the valid attribute targets for the current attribute context.
+    /// Returns <see cref="AttributeTargets.All"/> if not in an attribute context or if language-specific
+    /// filtering is not implemented.
+    /// </summary>
+    public virtual AttributeTargets ValidAttributeTargets => AttributeTargets.All;
+
     public TService? GetLanguageService<TService>() where TService : class, ILanguageService
         => Document.GetLanguageService<TService>();