RefToNotSupportedGenerator.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace Microsoft.Data.SqlClient.SourceGenerator
{
    [Generator]
    public class RefToNotSupportedGenerator : IIncrementalGenerator
    {
        private const string DefaultFileHeader =
        "//------------------------------------------------------------------------------\r\n" +
        "// <auto-generated>\r\n" +
        "//     This code was generated by a tool.\r\n" +
        "//     {0}\r\n" +
        "//\r\n" +
        "//     Changes to this file may cause incorrect behavior and will be lost if\r\n" +
        "//     the code is regenerated.\r\n" +
        "// </auto-generated>\r\n" +
        "//------------------------------------------------------------------------------\r\n";

        public void Initialize(IncrementalGeneratorInitializationContext context)
        {
            IncrementalValuesProvider<SyntaxNode> modelsProvider = context.SyntaxProvider
                .CreateSyntaxProvider(
                    predicate: (s, _) => IsSyntaxTargetForGeneration(s), 
                    transform: (ctx, _) => ctx.Node)
                .Where(m => m != null); // Filter out errors that we don't care about

            var modelProvider = modelsProvider
                .Collect()
                .Combine(context.AnalyzerConfigOptionsProvider);

            context.RegisterSourceOutput(
                modelProvider,
                (ctx, compilation) =>
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendFormat(DefaultFileHeader, nameof(RefToNotSupportedGenerator));
                    using (StringWriter writer = new StringWriter(sb))
                    {
                        if (!compilation.Right.GlobalOptions.TryGetValue("build_property.targetframework", out string framework))
                        {
                            throw new KeyNotFoundException("build_property.targetframework");
                        }

                        try
                        {
                            sb.AppendLine("using System;");
                            sb.AppendLine("#if NOTSUPPORTED");

                            RefToNotsupportedTypeRewriter visitor = new RefToNotsupportedTypeRewriter();
                            // Group all collected types by namespace. Expects source file name from ref library to match namespace of all incuded types  
                            foreach (var group in compilation.Left
                                .GroupBy(c => c.GetLocation().SourceTree.FilePath)
                                .OrderBy(cg => cg.Key)
                            )
                            {

                                sb.Append("namespace ");
                                sb.AppendLine(Path.GetFileNameWithoutExtension(group.Key));
                                sb.AppendLine("{");
                                foreach (SyntaxNode model in group)
                                {
                                    SyntaxNode result = visitor.Visit(model);
                                    result.WriteTo(writer);
                                }
                                sb.AppendLine("}");
                            }

                            sb.AppendLine("#endif");

                        }
                        catch (Exception ex)
                        {
                            sb.AppendLine($"// Exception:  {ex.Message}\r\n// StackTrace: {ex.StackTrace}");
                        }

                        ctx.AddSource($"Microsoft.Data.SqlClient.{framework}.notsupported.g.cs", sb.ToString());
                    }
                });
        }

        private static bool IsSyntaxTargetForGeneration(SyntaxNode node)
        {
            // Public delegates
            if (node is DelegateDeclarationSyntax membDecl && membDecl.Modifiers.Any(SyntaxKind.PublicKeyword))
            {
                return true;
            }
            // Public, or internal types
            if (node is BaseTypeDeclarationSyntax typeDecl &&
                (typeDecl.Modifiers.Any(SyntaxKind.PublicKeyword) || typeDecl.Modifiers.Any(SyntaxKind.InternalKeyword)))
            {
                return true;
            }

            return false;
        }
    }
}