Merge pull request #61293 from CyrusNajmabadi/attributeLookup

Add helper for source generators to filter to nodes with attribute matching an attribute name

src/Compilers/CSharp/Portable/SourceGeneration/CSharpGeneratorDriver.cs

@@ -4,10 +4,11 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.ComponentModel;
+using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.Diagnostics;
-using System.Linq;
-using System.ComponentModel;
+using Microsoft.CodeAnalysis.SourceGeneration;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -74,5 +75,7 @@ internal override SyntaxTree ParseGeneratedSourceText(GeneratedSourceText input,
  internal override CommonMessageProvider MessageProvider => CSharp.MessageProvider.Instance;
 
  internal override string SourceExtension => ".cs";
+
+ internal override ISyntaxHelper SyntaxHelper => CSharpSyntaxHelper.Instance;
  }
 }

src/Compilers/CSharp/Portable/SourceGeneration/CSharpSyntaxHelper.cs

@@ -0,0 +1,101 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.SourceGeneration;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Roslyn.Utilities;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+ internal sealed class CSharpSyntaxHelper : AbstractSyntaxHelper
+ {
+ public static readonly ISyntaxHelper Instance = new CSharpSyntaxHelper();
+
+ private CSharpSyntaxHelper()
+ {
+ }
+
+ public override bool IsCaseSensitive
+ => true;
+
+ public override bool IsValidIdentifier(string name)
+ => SyntaxFacts.IsValidIdentifier(name);
+
+ public override bool IsAnyNamespaceBlock(SyntaxNode node)
+ => node is BaseNamespaceDeclarationSyntax;
+
+ public override bool IsAttribute(SyntaxNode node)
+ => node is AttributeSyntax;
+
+ public override SyntaxNode GetNameOfAttribute(SyntaxNode node)
+ => ((AttributeSyntax)node).Name;
+
+ public override bool IsAttributeList(SyntaxNode node)
+ => node is AttributeListSyntax;
+
+ public override void AddAttributeTargets(SyntaxNode node, ArrayBuilder<SyntaxNode> targets)
+ {
+ var attributeList = (AttributeListSyntax)node;
+ var container = attributeList.Parent;
+ RoslynDebug.AssertNotNull(container);
+
+ // For fields/events, the attribute applies to all the variables declared.
+ if (container is FieldDeclarationSyntax field)
+ targets.AddRange(field.Declaration.Variables);
+ else if (container is EventFieldDeclarationSyntax ev)
+ targets.AddRange(ev.Declaration.Variables);
+ else
+ targets.Add(container);
+ }
+
+ public override SeparatedSyntaxList<SyntaxNode> GetAttributesOfAttributeList(SyntaxNode node)
+ => ((AttributeListSyntax)node).Attributes;
+
+ public override bool IsLambdaExpression(SyntaxNode node)
+ => node is LambdaExpressionSyntax;
+
+ public override SyntaxToken GetUnqualifiedIdentifierOfName(SyntaxNode node)
+ => ((NameSyntax)node).GetUnqualifiedName().Identifier;
+
+ public override void AddAliases(SyntaxNode node, ArrayBuilder<(string aliasName, string symbolName)> aliases, bool global)
+ {
+ if (node is CompilationUnitSyntax compilationUnit)
+ {
+ AddAliases(compilationUnit.Usings, aliases, global);
+ }
+ else if (node is BaseNamespaceDeclarationSyntax namespaceDeclaration)
+ {
+ AddAliases(namespaceDeclaration.Usings, aliases, global);
+ }
+ else
+ {
+ throw ExceptionUtilities.UnexpectedValue(node.Kind());
+ }
+ }
+
+ private static void AddAliases(SyntaxList<UsingDirectiveSyntax> usings, ArrayBuilder<(string aliasName, string symbolName)> aliases, bool global)
+ {
+ foreach (var usingDirective in usings)
+ {
+ if (usingDirective.Alias is null)
+ continue;
+
+ if (global != usingDirective.GlobalKeyword.Kind() is SyntaxKind.GlobalKeyword)
+ continue;
+
+ var aliasName = usingDirective.Alias.Name.Identifier.ValueText;
+ var symbolName = usingDirective.Name.GetUnqualifiedName().Identifier.ValueText;
+ aliases.Add((aliasName, symbolName));
+ }
+ }
+
+ public override void AddAliases(CompilationOptions compilation, ArrayBuilder<(string aliasName, string symbolName)> aliases)
+ {
+ // C# doesn't have global aliases at the compilation level.
+ return;
+ }
+ }
+}

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Types.cs

@@ -274,7 +274,15 @@ private void VisitNamedTypeWithoutNullability(INamedTypeSymbol symbol)
  if (IncludeNamedType(symbol.ContainingType))
  {
  symbol.ContainingType.Accept(this.NotFirstVisitor);
- AddPunctuation(SyntaxKind.DotToken);
+
+ if (format.CompilerInternalOptions.HasFlag(SymbolDisplayCompilerInternalOptions.UsePlusForNestedTypes))
+ {
+ AddPunctuation(SyntaxKind.PlusToken);
+ }
+ else
+ {
+ AddPunctuation(SyntaxKind.DotToken);
+ }
  }
  }