Polyfill the incremental generator ForAttributeWithMetadataName from roslyn.

src/libraries/Common/src/Roslyn/CSharpSyntaxHelper.cs

@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Microsoft.CodeAnalysis.DotnetRuntime.Extensions
+{
+    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, ref ValueListBuilder<SyntaxNode> targets)
+        {
+            var attributeList = (AttributeListSyntax)node;
+            var container = attributeList.Parent;
+            Debug.Assert(container != null);
+
+            // For fields/events, the attribute applies to all the variables declared.
+            if (container is FieldDeclarationSyntax field)
+            {
+                foreach (var variable in field.Declaration.Variables)
+                    targets.Append(variable);
+            }
+            else if (container is EventFieldDeclarationSyntax ev)
+            {
+                foreach (var variable in ev.Declaration.Variables)
+                    targets.Append(variable);
+            }
+            else
+            {
+                targets.Append(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, ref ValueListBuilder<(string aliasName, string symbolName)> aliases, bool global)
+        {
+            if (node is CompilationUnitSyntax compilationUnit)
+            {
+                AddAliases(compilationUnit.Usings, ref aliases, global);
+            }
+            else if (node is BaseNamespaceDeclarationSyntax namespaceDeclaration)
+            {
+                AddAliases(namespaceDeclaration.Usings, ref aliases, global);
+            }
+            else
+            {
+                throw new System.InvalidOperationException("Unreachable");
+            }
+        }
+
+        private static void AddAliases(SyntaxList<UsingDirectiveSyntax> usings, ref ValueListBuilder<(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.Append((aliasName, symbolName));
+            }
+        }
+
+        public override void AddAliases(CompilationOptions compilation, ref ValueListBuilder<(string aliasName, string symbolName)> aliases)
+        {
+            // C# doesn't have global aliases at the compilation level.
+            return;
+        }
+    }
+}

src/libraries/Common/src/Roslyn/GetBestTypeByMetadataName.cs

@@ -1,7 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+using System.Collections.Immutable;
+
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Microsoft.CodeAnalysis.DotnetRuntime.Extensions
 {
@@ -134,5 +138,34 @@ private enum SymbolVisibility
             Private = 2,
             Friend = Internal,
         }
+
+        internal static bool HasAttributeSuffix(this string name, bool isCaseSensitive)
+        {
+            const string AttributeSuffix = "Attribute";
+
+            var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
+            return name.Length > AttributeSuffix.Length && name.EndsWith(AttributeSuffix, comparison);
+        }
+
+        public static ImmutableArray<T> ToImmutableArray<T>(this ReadOnlySpan<T> span)
+        {
+            if (span.Length == 0)
+                return ImmutableArray<T>.Empty;
+
+            var builder = ImmutableArray.CreateBuilder<T>(span.Length);
+            foreach (var item in span)
+                builder.Add(item);
+
+            return builder.MoveToImmutable();
+        }
+
+        public static SimpleNameSyntax GetUnqualifiedName(this NameSyntax name)
+            => name switch
+            {
+                AliasQualifiedNameSyntax alias => alias.Name,
+                QualifiedNameSyntax qualified => qualified.Right,
+                SimpleNameSyntax simple => simple,
+                _ => throw new InvalidOperationException("Unreachable"),
+            };
     }
 }

src/libraries/Common/src/Roslyn/GlobalAliases.cs

@@ -0,0 +1,74 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.DotnetRuntime.Extensions;
+
+/// <summary>
+/// Simple wrapper class around an immutable array so we can have the value-semantics needed for the incremental
+/// generator to know when a change actually happened and it should run later transform stages.
+/// </summary>
+internal sealed class GlobalAliases : IEquatable<GlobalAliases>
+{
+    public static readonly GlobalAliases Empty = new(ImmutableArray<(string aliasName, string symbolName)>.Empty);
+
+    public readonly ImmutableArray<(string aliasName, string symbolName)> AliasAndSymbolNames;
+
+    private int _hashCode;
+
+    private GlobalAliases(ImmutableArray<(string aliasName, string symbolName)> aliasAndSymbolNames)
+    {
+        AliasAndSymbolNames = aliasAndSymbolNames;
+    }
+
+    public static GlobalAliases Create(ImmutableArray<(string aliasName, string symbolName)> aliasAndSymbolNames)
+    {
+        return aliasAndSymbolNames.IsEmpty ? Empty : new GlobalAliases(aliasAndSymbolNames);
+    }
+
+    public static GlobalAliases Concat(GlobalAliases ga1, GlobalAliases ga2)
+    {
+        if (ga1.AliasAndSymbolNames.Length == 0)
+            return ga2;
+
+        if (ga2.AliasAndSymbolNames.Length == 0)
+            return ga1;
+
+        return new(ga1.AliasAndSymbolNames.AddRange(ga2.AliasAndSymbolNames));
+    }
+
+    public override int GetHashCode()
+    {
+        if (_hashCode == 0)
+        {
+            var hashCode = 0;
+            foreach (var tuple in this.AliasAndSymbolNames)
+                hashCode = Hash.Combine(tuple.GetHashCode(), hashCode);
+
+            _hashCode = hashCode == 0 ? 1 : hashCode;
+        }
+
+        return _hashCode;
+    }
+
+    public override bool Equals(object? obj)
+        => this.Equals(obj as GlobalAliases);
+
+    public bool Equals(GlobalAliases? aliases)
+    {
+        if (aliases is null)
+            return false;
+
+        if (ReferenceEquals(this, aliases))
+            return true;
+
+        if (this.AliasAndSymbolNames == aliases.AliasAndSymbolNames)
+            return true;
+
+        return this.AliasAndSymbolNames.AsSpan().SequenceEqual(aliases.AliasAndSymbolNames.AsSpan());
+    }
+}