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

docs/project/list-of-diagnostics.md

@@ -212,10 +212,10 @@ The diagnostic id values reserved for .NET Libraries analyzer warnings are `SYSL
 |  __`SYSLIB1093`__ | _`SYSLIB1092`-`SYSLIB1099` reserved for Microsoft.Interop.ComInteropGenerator._ |
 |  __`SYSLIB1094`__ | _`SYSLIB1092`-`SYSLIB1099` reserved for Microsoft.Interop.ComInteropGenerator._ |
 |  __`SYSLIB1095`__ | _`SYSLIB1092`-`SYSLIB1099` reserved for Microsoft.Interop.ComInteropGenerator._ |
-|  __`SYSLIB1096`__ | _`SYSLIB1092`-`SYSLIB1099` reserved for Microsoft.Interop.ComInteropGenerator._ |
-|  __`SYSLIB1097`__ | _`SYSLIB1092`-`SYSLIB1099` reserved for Microsoft.Interop.ComInteropGenerator._ |
-|  __`SYSLIB1098`__ | _`SYSLIB1092`-`SYSLIB1099` reserved for Microsoft.Interop.ComInteropGenerator._ |
-|  __`SYSLIB1099`__ | _`SYSLIB1092`-`SYSLIB1099` reserved for Microsoft.Interop.ComInteropGenerator._ |
+|  __`SYSLIB1096`__ | Use 'GeneratedComInterfaceAttribute' instead of 'ComImportAttribute' to generate COM marshalling code at compile time |
+|  __`SYSLIB1097`__ | This type implements at least one type with the 'GeneratedComInterfaceAttribute' attribute. Add the 'GeneratedComClassAttribute' to enable passing this type to COM and exposing the COM interfaces for the types with the 'GeneratedComInterfaceAttribute' from objects of this type. |
+|  __`SYSLIB1098`__ | .NET COM hosting with 'EnableComHosting' only supports built-in COM interop. It does not support source-generated COM interop with 'GeneratedComInterfaceAttribute'. |
+|  __`SYSLIB1099`__ | COM Interop APIs on 'System.Runtime.InteropServices.Marshal' do not support source-generated COM and will fail at runtime |
 |  __`SYSLIB1100`__ | Configuration binding generator: type is not supported. |
 |  __`SYSLIB1101`__ | Configuration binding generator: property on type is not supported. |
 |  __`SYSLIB1102`__ | Configuration binding generator: project's language version must be at least C# 11.|

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

@@ -0,0 +1,59 @@
+// 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;
+                    }
+
+                    // Only direct people to put the GeneratedComClassAttribute on classes.
+                    if (type.TypeKind != TypeKind.Class)
+                    {
+                        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);
+            });
+        }
+    }
+}