Add analyzers and code-fixes to help adoption of source-generated COM

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/AddGeneratedComClassAnalyzer.cs

@@ -0,0 +1,53 @@
+// 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.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.DotnetRuntime.Extensions;
+using static Microsoft.Interop.Analyzers.AnalyzerDiagnostics;
+
+namespace Microsoft.Interop.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class AddGeneratedComClassAnalyzer : DiagnosticAnalyzer
+    {
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(AddGeneratedComClassAttribute);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+
+            context.RegisterCompilationStartAction(context =>
+            {
+                var generatedComClassAttributeType = context.Compilation.GetBestTypeByMetadataName(TypeNames.GeneratedComClassAttribute);
+                var generatedComInterfaceAttributeType = context.Compilation.GetBestTypeByMetadataName(TypeNames.GeneratedComInterfaceAttribute);
+
+                if (generatedComClassAttributeType is null || generatedComInterfaceAttributeType is null)
+                {
+                    return;
+                }
+
+                context.RegisterSymbolAction(context =>
+                {
+                    INamedTypeSymbol type = (INamedTypeSymbol)context.Symbol;
+                    if (type.GetAttributes().Any(attr => generatedComClassAttributeType.Equals(attr.AttributeClass, SymbolEqualityComparer.Default)))
+                    {
+                        return;
+                    }
+
+                    foreach (var iface in type.AllInterfaces)
+                    {
+                        if (iface.GetAttributes().Any(attr => generatedComInterfaceAttributeType.Equals(attr.AttributeClass, SymbolEqualityComparer.Default)))
+                        {
+                            context.ReportDiagnostic(type.CreateDiagnostic(AddGeneratedComClassAttribute, type.Name));
+                            return;
+                        }
+                    }
+                }, SymbolKind.NamedType);
+            });
+        }
+    }
+}

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/AddGeneratedComClassFixer.cs

@@ -0,0 +1,62 @@
+// 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 System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.DotnetRuntime.Extensions;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Simplification;
+
+namespace Microsoft.Interop.Analyzers
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
+    public class AddGeneratedComClassFixer : ConvertToSourceGeneratedInteropFixer
+    {
+        public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(AnalyzerDiagnostics.Ids.AddGeneratedComClassAttribute);
+
+        protected override string BaseEquivalenceKey => nameof(AddGeneratedComClassFixer);
+
+        private static Task AddGeneratedComClassAsync(DocumentEditor editor, SyntaxNode node)
+        {
+            editor.ReplaceNode(node, (node, gen) =>
+            {
+                var attribute = gen.Attribute(gen.TypeExpression(editor.SemanticModel.Compilation.GetBestTypeByMetadataName(TypeNames.GeneratedComClassAttribute)).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation));
+                var updatedNode = gen.AddAttributes(node, attribute);
+                var declarationModifiers = gen.GetModifiers(updatedNode);
+                if (!declarationModifiers.IsPartial)
+                {
+                    updatedNode = gen.WithModifiers(updatedNode, declarationModifiers.WithPartial(true));
+                }
+                return updatedNode;
+            });
+
+            MakeNodeParentsPartial(editor, node);
+
+            return Task.CompletedTask;
+        }
+
+        protected override Func<DocumentEditor, CancellationToken, Task> CreateFixForSelectedOptions(SyntaxNode node, ImmutableDictionary<string, Option> selectedOptions)
+        {
+            return (editor, _) => AddGeneratedComClassAsync(editor, node);
+        }
+
+        protected override string GetDiagnosticTitle(ImmutableDictionary<string, Option> selectedOptions)
+        {
+            bool allowUnsafe = selectedOptions.TryGetValue(Option.AllowUnsafe, out var allowUnsafeOption) && allowUnsafeOption is Option.Bool(true);
+
+            return allowUnsafe
+                ? SR.AddGeneratedComClassAttributeTitle
+                : SR.AddGeneratedComClassAddUnsafe;
+        }
+
+        protected override ImmutableDictionary<string, Option> ParseOptionsFromDiagnostic(Diagnostic diagnostic)
+        {
+            return ImmutableDictionary<string, Option>.Empty;
+        }
+    }
+}

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/AnalyzerDiagnostics.cs

@@ -11,9 +11,19 @@ public static class Ids
         {
             public const string Prefix = "SYSLIB";
             public const string InvalidGeneratedComAttributeUsage = Prefix + "1090";
+            public const string ConvertToGeneratedComInterface = Prefix + "1096";
+            public const string AddGeneratedComClassAttribute = Prefix + "1097";
+            public const string ComHostingDoesNotSupportGeneratedComInterface = Prefix + "1098";
+            public const string RuntimeComApisDoNotSupportSourceGeneratedCom = Prefix + "1099";
         }
 
-        private const string Category = "ComInterfaceGenerator";
+        public static class Metadata
+        {
+            public const string MayRequireAdditionalWork = nameof(MayRequireAdditionalWork);
+            public const string AddStringMarshalling = nameof(AddStringMarshalling);
+        }
+
+        private const string Category = "Interoperability";
 
         private static LocalizableResourceString GetResourceString(string resourceName)
         {
@@ -29,5 +39,45 @@ private static LocalizableResourceString GetResourceString(string resourceName)
                 DiagnosticSeverity.Error,
                 isEnabledByDefault: true,
                 description: GetResourceString(nameof(SR.InterfaceTypeNotSupportedMessage)));
+
+        public static readonly DiagnosticDescriptor ConvertToGeneratedComInterface =
+            new DiagnosticDescriptor(
+                Ids.ConvertToGeneratedComInterface,
+                GetResourceString(nameof(SR.ConvertToGeneratedComInterfaceTitle)),
+                GetResourceString(nameof(SR.ConvertToGeneratedComInterfaceMessage)),
+                Category,
+                DiagnosticSeverity.Info,
+                isEnabledByDefault: true,
+                description: GetResourceString(nameof(SR.ConvertToGeneratedComInterfaceDescription)));
+
+        public static readonly DiagnosticDescriptor AddGeneratedComClassAttribute =
+            new DiagnosticDescriptor(
+                Ids.AddGeneratedComClassAttribute,
+                GetResourceString(nameof(SR.AddGeneratedComClassAttributeTitle)),
+                GetResourceString(nameof(SR.AddGeneratedComClassAttributeMessage)),
+                Category,
+                DiagnosticSeverity.Info,
+                isEnabledByDefault: true,
+                description: GetResourceString(nameof(SR.AddGeneratedComClassAttributeDescription)));
+
+        public static readonly DiagnosticDescriptor ComHostingDoesNotSupportGeneratedComInterface =
+            new DiagnosticDescriptor(
+                Ids.ComHostingDoesNotSupportGeneratedComInterface,
+                GetResourceString(nameof(SR.ComHostingDoesNotSupportGeneratedComInterfaceTitle)),
+                GetResourceString(nameof(SR.ComHostingDoesNotSupportGeneratedComInterfaceMessage)),
+                Category,
+                DiagnosticSeverity.Warning,
+                isEnabledByDefault: true,
+                description: GetResourceString(nameof(SR.ComHostingDoesNotSupportGeneratedComInterfaceDescription)));
+
+        public static readonly DiagnosticDescriptor RuntimeComApisDoNotSupportSourceGeneratedCom =
+            new DiagnosticDescriptor(
+                Ids.RuntimeComApisDoNotSupportSourceGeneratedCom,
+                GetResourceString(nameof(SR.RuntimeComApisDoNotSupportSourceGeneratedComTitle)),
+                GetResourceString(nameof(SR.RuntimeComApisDoNotSupportSourceGeneratedComMessage)),
+                Category,
+                DiagnosticSeverity.Warning,
+                isEnabledByDefault: true,
+                description: GetResourceString(nameof(SR.RuntimeComApisDoNotSupportSourceGeneratedComDescription)));
     }
 }

src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/ComHostingDoesNotSupportGeneratedComInterfaceAnalyzer.cs

@@ -0,0 +1,71 @@
+// 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.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.DotnetRuntime.Extensions;
+using Microsoft.CodeAnalysis.Operations;
+using static Microsoft.Interop.Analyzers.AnalyzerDiagnostics;
+
+namespace Microsoft.Interop.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ComHostingDoesNotSupportGeneratedComInterfaceAnalyzer : DiagnosticAnalyzer
+    {
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(ComHostingDoesNotSupportGeneratedComInterface);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+            context.RegisterCompilationStartAction(context =>
+            {
+                if (!context.Options.AnalyzerConfigOptionsProvider.GlobalOptions.TryGetValue("build_property.EnableComHosting", out string? enableComHosting)
+                    || !bool.TryParse(enableComHosting, out bool enableComHostingValue)
+                    || !enableComHostingValue)
+                {
+                    return;
+                }
+
+                INamedTypeSymbol? generatedComClassAttribute = context.Compilation.GetBestTypeByMetadataName(TypeNames.GeneratedComClassAttribute);
+                INamedTypeSymbol? generatedComInterfaceAttribute = context.Compilation.GetBestTypeByMetadataName(TypeNames.GeneratedComInterfaceAttribute);
+                INamedTypeSymbol? comVisibleAttribute = context.Compilation.GetBestTypeByMetadataName(TypeNames.System_Runtime_InteropServices_ComVisibleAttribute)!;
+
+                if (generatedComClassAttribute is null || generatedComInterfaceAttribute is null || comVisibleAttribute is null)
+                {
+                    return;
+                }
+
+                context.RegisterOperationAction(context =>
+                {
+                    IAttributeOperation attr = (IAttributeOperation)context.Operation;
+                    if (attr.Operation is not IObjectCreationOperation ctor
+                        || !comVisibleAttribute.Equals(ctor.Type, SymbolEqualityComparer.Default)
+                        || ctor.Arguments[0].Value.ConstantValue.Value is not true)
+                    {
+                        return;
+                    }
+
+                    INamedTypeSymbol containingType = (INamedTypeSymbol)context.ContainingSymbol;
+
+                    if (containingType.GetAttributes().Any(attr => generatedComClassAttribute.Equals(attr.AttributeClass, SymbolEqualityComparer.Default)))
+                    {
+                        context.ReportDiagnostic(context.ContainingSymbol.CreateDiagnostic(ComHostingDoesNotSupportGeneratedComInterface, context.ContainingSymbol.Name));
+                        return;
+                    }
+
+                    foreach (var iface in containingType.AllInterfaces)
+                    {
+                        if (iface.GetAttributes().Any(attr => generatedComInterfaceAttribute.Equals(attr.AttributeClass, SymbolEqualityComparer.Default)))
+                        {
+                            context.ReportDiagnostic(context.ContainingSymbol.CreateDiagnostic(ComHostingDoesNotSupportGeneratedComInterface, context.ContainingSymbol.Name));
+                            return;
+                        }
+                    }
+                }, OperationKind.Attribute);
+            });
+        }
+    }
+}